← Back to branch summary

~valavanisalex/ubuntu/precise/inkscape/fix-943984

« back to all changes in this revision

Viewing changes to inkscape-0.47pre1/src/dom/svgtypes.h

  • Committer: Bazaar Package Importer
  • Author(s): Bryce Harrington
  • Date: 2009-07-02 17:09:45 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20090702170945-nn6d6zswovbwju1t
Tags: 0.47~pre1-0ubuntu1
https://launchpad.net/bugs/348842
https://launchpad.net/bugs/391149
* New upstream release.
  - Don't constrain maximization on small resolution devices (pre0)
    (LP: #348842)
  - Fixes segfault on startup (pre0)
    (LP: #391149)

Show diffs side-by-side

added added

removed removed

Lines of Context:
inkscape-0.47pre1/src/dom/svgtypes.h
 
1
#ifndef __SVGTYPES_H__
 
2
#define __SVGTYPES_H__
 
3
 
 
4
/**
 
5
 * Phoebe DOM Implementation.
 
6
 *
 
7
 * This is a C++ approximation of the W3C DOM model, which follows
 
8
 * fairly closely the specifications in the various .idl files, copies of
 
9
 * which are provided for reference.  Most important is this one:
 
10
 *
 
11
 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
 
12
 *
 
13
 * Authors:
 
14
 *   Bob Jamison
 
15
 *
 
16
 * Copyright (C) 2006-2008 Bob Jamison
 
17
 *
 
18
 *  This library is free software; you can redistribute it and/or
 
19
 *  modify it under the terms of the GNU Lesser General Public
 
20
 *  License as published by the Free Software Foundation; either
 
21
 *  version 2.1 of the License, or (at your option) any later version.
 
22
 *
 
23
 *  This library is distributed in the hope that it will be useful,
 
24
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
25
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
26
 *  Lesser General Public License for more details.
 
27
 *
 
28
 *  You should have received a copy of the GNU Lesser General Public
 
29
 *  License along with this library; if not, write to the Free Software
 
30
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
31
 *  
 
32
 * =======================================================================
 
33
 * NOTES
 
34
 * 
 
35
 * This API follows:
 
36
 * http://www.w3.org/TR/SVG11/svgdom.html
 
37
 * 
 
38
 * This file contains the definitions of the non-Node SVG classes.  DOM Nodes
 
39
 * for SVG are defined in svg.h.
 
40
 *          
 
41
 */
 
42
 
 
43
 
 
44
// For access to DOM2 core
 
45
#include "dom/dom.h"
 
46
 
 
47
// For access to DOM2 events
 
48
#include "dom/events.h"
 
49
 
 
50
// For access to those parts from DOM2 CSS OM used by SVG DOM.
 
51
#include "dom/css.h"
 
52
 
 
53
// For access to those parts from DOM2 Views OM used by SVG DOM.
 
54
#include "dom/views.h"
 
55
 
 
56
// For access to the SMIL OM used by SVG DOM.
 
57
#include "dom/smil.h"
 
58
 
 
59
 
 
60
#include <cstdio>
 
61
#include <math.h>
 
62
 
 
63
 
 
64
 
 
65
namespace org {
 
66
namespace w3c {
 
67
namespace dom {
 
68
namespace svg {
 
69
 
 
70
 
 
71
 
 
72
 
 
73
//local definitions
 
74
typedef dom::DOMString DOMString;
 
75
typedef dom::DOMException DOMException;
 
76
typedef dom::Element Element;
 
77
typedef dom::Document Document;
 
78
typedef dom::NodeList NodeList;
 
79
 
 
80
 
 
81
class SVGElement;
 
82
typedef Ptr<SVGElement> SVGElementPtr;
 
83
class SVGUseElement;
 
84
typedef Ptr<SVGUseElement> SVGUseElementPtr;
 
85
class SVGAnimatedPreserveAspectRatio;
 
86
 
 
87
 
 
88
/*#########################################################################
 
89
## SVGException
 
90
#########################################################################*/
 
91
 
 
92
/**
 
93
 *
 
94
 */
 
95
class SVGException
 
96
{
 
97
public:
 
98
    // unsigned short   code;  //inherited
 
99
};
 
100
 
 
101
    /**
 
102
     * SVGExceptionCode
 
103
     */
 
104
    typedef enum
 
105
        {
 
106
        SVG_WRONG_TYPE_ERR           = 0,
 
107
        SVG_INVALID_VALUE_ERR        = 1,
 
108
        SVG_MATRIX_NOT_INVERTABLE    = 2
 
109
        } SVGExceptionCode;
 
110
 
 
111
 
 
112
 
 
113
 
 
114
 
 
115
/*#########################################################################
 
116
## SVGMatrix
 
117
#########################################################################*/
 
118
 
 
119
/**
 
120
 *  In SVG, a Matrix is defined like this:
 
121
 *
 
122
 * | a  c  e |
 
123
 * | b  d  f |
 
124
 * | 0  0  1 |
 
125
 *
 
126
 */
 
127
class SVGMatrix
 
128
{
 
129
public:
 
130
 
 
131
 
 
132
    /**
 
133
     *
 
134
     */
 
135
    virtual double getA()
 
136
        { return a; }
 
137
 
 
138
    /**
 
139
     *
 
140
     */
 
141
    virtual void setA(double val) throw (DOMException)
 
142
        { a = val; }
 
143
 
 
144
    /**
 
145
     *
 
146
     */
 
147
    virtual double getB()
 
148
        { return b; }
 
149
 
 
150
    /**
 
151
     *
 
152
     */
 
153
    virtual void setB(double val) throw (DOMException)
 
154
        { b = val; }
 
155
 
 
156
    /**
 
157
     *
 
158
     */
 
159
    virtual double getC()
 
160
        { return c; }
 
161
 
 
162
    /**
 
163
     *
 
164
     */
 
165
    virtual void setC(double val) throw (DOMException)
 
166
        { c = val; }
 
167
 
 
168
    /**
 
169
     *
 
170
     */
 
171
    virtual double getD()
 
172
        { return d; }
 
173
 
 
174
    /**
 
175
     *
 
176
     */
 
177
    virtual void setD(double val) throw (DOMException)
 
178
        { d = val; }
 
179
    /**
 
180
     *
 
181
     */
 
182
    virtual double getE()
 
183
        { return e; }
 
184
 
 
185
    /**
 
186
     *
 
187
     */
 
188
    virtual void setE(double val) throw (DOMException)
 
189
        { e = val; }
 
190
    /**
 
191
     *
 
192
     */
 
193
    virtual double getF()
 
194
        { return f; }
 
195
 
 
196
    /**
 
197
     *
 
198
     */
 
199
    virtual void setF(double val) throw (DOMException)
 
200
        { f = val; }
 
201
 
 
202
 
 
203
    /**
 
204
     * Return the result of postmultiplying this matrix with another.
 
205
     */
 
206
    virtual SVGMatrix multiply(const SVGMatrix &other)
 
207
        {
 
208
        SVGMatrix result;
 
209
        result.a = a * other.a  +  c * other.b;
 
210
        result.b = b * other.a  +  d * other.b;
 
211
        result.c = a * other.c  +  c * other.d;
 
212
        result.d = b * other.c  +  d * other.d;
 
213
        result.e = a * other.e  +  c * other.f  +  e;
 
214
        result.f = b * other.e  +  d * other.f  +  f;
 
215
        return result;
 
216
        }
 
217
 
 
218
    /**
 
219
     *  Calculate the inverse of this matrix
 
220
     *
 
221
     */
 
222
    virtual SVGMatrix inverse(  ) throw( SVGException )
 
223
        {
 
224
        /*###########################################
 
225
        The determinant of a 3x3 matrix E
 
226
           (let's use our own notation for a bit)
 
227
 
 
228
            A  B  C
 
229
            D  E  F
 
230
            G  H  I
 
231
        is
 
232
            AEI - AFH - BDI + BFG + CDH - CEG
 
233
 
 
234
        Since in our affine transforms, G and H==0 and I==1,
 
235
        this reduces to:
 
236
            AE - BD
 
237
        In SVG's naming scheme, that is:  a * d - c * b .  SIMPLE!
 
238
 
 
239
        In a similar method of attack, SVG's adjunct matrix is:
 
240
 
 
241
           d  -c   cf-ed
 
242
          -b   a   eb-af
 
243
           0   0   ad-cb
 
244
 
 
245
        To get the inverse matrix, we divide the adjunct matrix by
 
246
        the determinant.  Notice that (ad-cb)/(ad-cb)==1.  Very cool.
 
247
        So what we end up with is this:
 
248
 
 
249
           a =  d/(ad-cb)  c = -c/(ad-cb)   e = (cf-ed)/(ad-cb)
 
250
           b = -b/(ad-cb)  d =  a/(ad-cb)   f = (eb-af)/(ad-cb)
 
251
 
 
252
        (Since this would be in all SVG-DOM implementations,
 
253
         somebody needed to document this!  ^^ )
 
254
        #############################################*/
 
255
 
 
256
        SVGMatrix result;
 
257
        double determinant = a * d  -  c * b;
 
258
        if (determinant < 1.0e-18)//invertible?
 
259
            {
 
260
            result.identity();//cop out
 
261
            return result;
 
262
            }
 
263
 
 
264
        double idet = 1.0 / determinant;
 
265
        result.a =   d * idet;
 
266
        result.b =  -b * idet;
 
267
        result.c =  -c * idet;
 
268
        result.d =   a * idet;
 
269
        result.e =  (c*f - e*d) * idet;
 
270
        result.f =  (e*b - a*f) * idet;
 
271
        return result;
 
272
        }
 
273
 
 
274
    /**
 
275
     * Equivalent to multiplying by:
 
276
     *  | 1  0  x |
 
277
     *  | 0  1  y |
 
278
     *  | 0  0  1 |
 
279
     *
 
280
     */
 
281
    virtual SVGMatrix translate(double x, double y )
 
282
        {
 
283
        SVGMatrix result;
 
284
        result.a = a;
 
285
        result.b = b;
 
286
        result.c = c;
 
287
        result.d = d;
 
288
        result.e = a * x  +  c * y  +  e;
 
289
        result.f = b * x  +  d * y  +  f;
 
290
        return result;
 
291
        }
 
292
 
 
293
    /**
 
294
     * Equivalent to multiplying by:
 
295
     *  | scale  0      0 |
 
296
     *  | 0      scale  0 |
 
297
     *  | 0      0      1 |
 
298
     *
 
299
     */
 
300
    virtual SVGMatrix scale(double scale)
 
301
        {
 
302
        SVGMatrix result;
 
303
        result.a = a * scale;
 
304
        result.b = b * scale;
 
305
        result.c = c * scale;
 
306
        result.d = d * scale;
 
307
        result.e = e;
 
308
        result.f = f;
 
309
        return result;
 
310
        }
 
311
 
 
312
    /**
 
313
     * Equivalent to multiplying by:
 
314
     *  | scaleX  0       0 |
 
315
     *  | 0       scaleY  0 |
 
316
     *  | 0       0       1 |
 
317
     *
 
318
     */
 
319
    virtual SVGMatrix scaleNonUniform(double scaleX,
 
320
                                      double scaleY )
 
321
        {
 
322
        SVGMatrix result;
 
323
        result.a = a * scaleX;
 
324
        result.b = b * scaleX;
 
325
        result.c = c * scaleY;
 
326
        result.d = d * scaleY;
 
327
        result.e = e;
 
328
        result.f = f;
 
329
        return result;
 
330
        }
 
331
 
 
332
    /**
 
333
     * Equivalent to multiplying by:
 
334
     *  | cos(a) -sin(a)   0 |
 
335
     *  | sin(a)  cos(a)   0 |
 
336
     *  | 0       0        1 |
 
337
     *
 
338
     */
 
339
    virtual SVGMatrix rotate (double angle)
 
340
        {
 
341
        double sina  = sin(angle);
 
342
        double msina = -sina;
 
343
        double cosa  = cos(angle);
 
344
        SVGMatrix result;
 
345
        result.a = a * cosa   +  c * sina;
 
346
        result.b = b * cosa   +  d + sina;
 
347
        result.c = a * msina  +  c * cosa;
 
348
        result.d = b * msina  +  d * cosa;
 
349
        result.e = e;
 
350
        result.f = f;
 
351
        return result;
 
352
        }
 
353
 
 
354
    /**
 
355
     * Equivalent to multiplying by:
 
356
     *  | cos(a) -sin(a)   0 |
 
357
     *  | sin(a)  cos(a)   0 |
 
358
     *  | 0       0        1 |
 
359
     *  In this case, angle 'a' is computed as the artangent
 
360
     *  of the slope y/x .  It is negative if the slope is negative.
 
361
     */
 
362
    virtual SVGMatrix rotateFromVector(double x, double y)
 
363
                                      throw( SVGException )
 
364
        {
 
365
        double angle = atan(y / x);
 
366
        if (y < 0.0)
 
367
            angle = -angle;
 
368
        SVGMatrix result;
 
369
        double sina  = sin(angle);
 
370
        double msina = -sina;
 
371
        double cosa  = cos(angle);
 
372
        result.a = a * cosa   +  c * sina;
 
373
        result.b = b * cosa   +  d + sina;
 
374
        result.c = a * msina  +  c * cosa;
 
375
        result.d = b * msina  +  d * cosa;
 
376
        result.e = e;
 
377
        result.f = f;
 
378
        return result;
 
379
        }
 
380
 
 
381
    /**
 
382
     * Equivalent to multiplying by:
 
383
     *  | -1   0   0 |
 
384
     *  | 0    1   0 |
 
385
     *  | 0    0   1 |
 
386
     *
 
387
     */
 
388
    virtual SVGMatrix flipX(  )
 
389
        {
 
390
        SVGMatrix result;
 
391
        result.a = -a;
 
392
        result.b = -b;
 
393
        result.c =  c;
 
394
        result.d =  d;
 
395
        result.e =  e;
 
396
        result.f =  f;
 
397
        return result;
 
398
        }
 
399
 
 
400
    /**
 
401
     * Equivalent to multiplying by:
 
402
     *  | 1   0   0 |
 
403
     *  | 0  -1   0 |
 
404
     *  | 0   0   1 |
 
405
     *
 
406
     */
 
407
    virtual SVGMatrix flipY( )
 
408
        {
 
409
        SVGMatrix result;
 
410
        result.a =  a;
 
411
        result.b =  b;
 
412
        result.c = -c;
 
413
        result.d = -d;
 
414
        result.e =  e;
 
415
        result.f =  f;
 
416
        return result;
 
417
        }
 
418
 
 
419
    /**
 
420
     *  | 1   tan(a)  0 |
 
421
     *  | 0   1       0 |
 
422
     *  | 0   0       1 |
 
423
     *
 
424
     */
 
425
    virtual SVGMatrix skewX(double angle)
 
426
        {
 
427
        double tana = tan(angle);
 
428
        SVGMatrix result;
 
429
        result.a =  a;
 
430
        result.b =  b;
 
431
        result.c =  a * tana + c;
 
432
        result.d =  b * tana + d;
 
433
        result.e =  e;
 
434
        result.f =  f;
 
435
        return result;
 
436
        }
 
437
 
 
438
    /**
 
439
     * Equivalent to multiplying by:
 
440
     *  | 1       0   0 |
 
441
     *  | tan(a)  1   0 |
 
442
     *  | 0       0   1 |
 
443
     *
 
444
     */
 
445
    virtual SVGMatrix skewY(double angle)
 
446
        {
 
447
        double tana = tan(angle);
 
448
        SVGMatrix result;
 
449
        result.a =  a + c * tana;
 
450
        result.b =  b + d * tana;
 
451
        result.c =  c;
 
452
        result.d =  d;
 
453
        result.e =  e;
 
454
        result.f =  f;
 
455
        return result;
 
456
        }
 
457
 
 
458
 
 
459
 
 
460
    //##################
 
461
    //# Non-API methods
 
462
    //##################
 
463
 
 
464
    /**
 
465
     *
 
466
     */
 
467
    SVGMatrix()
 
468
        {
 
469
        identity();
 
470
        }
 
471
 
 
472
    /**
 
473
     *
 
474
     */
 
475
    SVGMatrix(double aArg, double bArg, double cArg,
 
476
              double dArg, double eArg, double fArg )
 
477
        {
 
478
        a = aArg; b = bArg; c = cArg;
 
479
        d = dArg; e = eArg; f = fArg;
 
480
        }
 
481
 
 
482
    /**
 
483
     * Copy constructor
 
484
     */
 
485
    SVGMatrix(const SVGMatrix &other)
 
486
        {
 
487
        a = other.a;
 
488
        b = other.b;
 
489
        c = other.c;
 
490
        d = other.d;
 
491
        e = other.e;
 
492
        f = other.f;
 
493
        }
 
494
 
 
495
 
 
496
 
 
497
    /**
 
498
     *
 
499
     */
 
500
    virtual ~SVGMatrix() {}
 
501
 
 
502
protected:
 
503
 
 
504
friend class SVGTransform;
 
505
 
 
506
    /*
 
507
     * Set to the identify matrix
 
508
     */
 
509
   void identity()
 
510
       {
 
511
       a = 1.0;
 
512
       b = 0.0;
 
513
       c = 0.0;
 
514
       d = 1.0;
 
515
       e = 0.0;
 
516
       f = 0.0;
 
517
       }
 
518
 
 
519
    double a, b, c, d, e, f;
 
520
 
 
521
};
 
522
 
 
523
 
 
524
/*#########################################################################
 
525
## SVGTransform
 
526
#########################################################################*/
 
527
 
 
528
/**
 
529
 *
 
530
 */
 
531
class SVGTransform
 
532
{
 
533
public:
 
534
 
 
535
    /**
 
536
     * Transform Types
 
537
     */
 
538
    typedef enum
 
539
        {
 
540
        SVG_TRANSFORM_UNKNOWN   = 0,
 
541
        SVG_TRANSFORM_MATRIX    = 1,
 
542
        SVG_TRANSFORM_TRANSLATE = 2,
 
543
        SVG_TRANSFORM_SCALE     = 3,
 
544
        SVG_TRANSFORM_ROTATE    = 4,
 
545
        SVG_TRANSFORM_SKEWX     = 5,
 
546
        SVG_TRANSFORM_SKEWY     = 6,
 
547
        } TransformType;
 
548
 
 
549
    /**
 
550
     *
 
551
     */
 
552
    virtual unsigned short getType()
 
553
        { return type; }
 
554
 
 
555
 
 
556
    /**
 
557
     *
 
558
     */
 
559
    virtual SVGMatrix getMatrix()
 
560
        {
 
561
        return matrix;
 
562
        }
 
563
 
 
564
    /**
 
565
     *
 
566
     */
 
567
    virtual double getAngle()
 
568
        {
 
569
        return angle;
 
570
        }
 
571
 
 
572
 
 
573
    /**
 
574
     *
 
575
     */
 
576
    virtual void setMatrix(const SVGMatrix &matrixArg)
 
577
        {
 
578
        type = SVG_TRANSFORM_MATRIX;
 
579
        matrix = matrixArg;
 
580
        }
 
581
 
 
582
    /**
 
583
     *
 
584
     */
 
585
    virtual void setTranslate (double tx, double ty )
 
586
        {
 
587
        type = SVG_TRANSFORM_TRANSLATE;
 
588
        matrix.setA(1.0);
 
589
        matrix.setB(0.0);
 
590
        matrix.setC(0.0);
 
591
        matrix.setD(1.0);
 
592
        matrix.setE(tx);
 
593
        matrix.setF(ty);
 
594
        }
 
595
 
 
596
    /**
 
597
     *
 
598
     */
 
599
    virtual void setScale (double sx, double sy )
 
600
        {
 
601
        type = SVG_TRANSFORM_SCALE;
 
602
        matrix.setA(sx);
 
603
        matrix.setB(0.0);
 
604
        matrix.setC(0.0);
 
605
        matrix.setD(sy);
 
606
        matrix.setE(0.0);
 
607
        matrix.setF(0.0);
 
608
        }
 
609
 
 
610
    /**
 
611
     *
 
612
     */
 
613
    virtual void setRotate (double angleArg, double cx, double cy)
 
614
        {
 
615
        angle = angleArg;
 
616
        setTranslate(cx, cy);
 
617
        type = SVG_TRANSFORM_ROTATE;
 
618
        matrix.rotate(angle);
 
619
        }
 
620
 
 
621
    /**
 
622
     *
 
623
     */
 
624
    virtual void setSkewX (double angleArg)
 
625
        {
 
626
        angle = angleArg;
 
627
        type = SVG_TRANSFORM_SKEWX;
 
628
        matrix.identity();
 
629
        matrix.skewX(angle);
 
630
        }
 
631
 
 
632
    /**
 
633
     *
 
634
     */
 
635
    virtual void setSkewY (double angleArg)
 
636
        {
 
637
        angle = angleArg;
 
638
        type = SVG_TRANSFORM_SKEWY;
 
639
        matrix.identity();
 
640
        matrix.skewY(angle);
 
641
        }
 
642
 
 
643
 
 
644
    //##################
 
645
    //# Non-API methods
 
646
    //##################
 
647
 
 
648
    /**
 
649
     *
 
650
     */
 
651
    SVGTransform()
 
652
        {
 
653
        type = SVG_TRANSFORM_UNKNOWN;
 
654
        angle = 0.0;
 
655
        }
 
656
 
 
657
    /**
 
658
     *
 
659
     */
 
660
    SVGTransform(const SVGTransform &other)
 
661
        {
 
662
        type   = other.type;
 
663
        angle  = other.angle;
 
664
        matrix = other.matrix;
 
665
        }
 
666
 
 
667
    /**
 
668
     *
 
669
     */
 
670
    virtual ~SVGTransform()
 
671
        {}
 
672
 
 
673
protected:
 
674
 
 
675
    int type;
 
676
    double angle;
 
677
 
 
678
    SVGMatrix matrix;
 
679
};
 
680
 
 
681
 
 
682
 
 
683
 
 
684
 
 
685
 
 
686
/*#########################################################################
 
687
## SVGTransformList
 
688
#########################################################################*/
 
689
 
 
690
/**
 
691
 *
 
692
 */
 
693
class SVGTransformList
 
694
{
 
695
public:
 
696
 
 
697
 
 
698
    /**
 
699
     *
 
700
     */
 
701
    virtual unsigned long getNumberOfItems()
 
702
        { return items.size(); }
 
703
 
 
704
 
 
705
    /**
 
706
     *
 
707
     */
 
708
    virtual void clear( ) throw( DOMException )
 
709
        { items.clear(); }
 
710
 
 
711
    /**
 
712
     *
 
713
     */
 
714
    virtual SVGTransform initialize (const SVGTransform &newItem)
 
715
                         throw( DOMException, SVGException )
 
716
        {
 
717
        items.clear();
 
718
        items.push_back(newItem);
 
719
        return newItem;
 
720
        }
 
721
 
 
722
    /**
 
723
     *
 
724
     */
 
725
    virtual SVGTransform getItem (unsigned long index )
 
726
                    throw( DOMException )
 
727
        {
 
728
        if (index>=items.size())
 
729
            {
 
730
            SVGTransform transform;
 
731
            return transform;
 
732
            }
 
733
        return items[index];
 
734
        }
 
735
 
 
736
    /**
 
737
     *
 
738
     */
 
739
    virtual SVGTransform insertItemBefore (const SVGTransform &newItem,
 
740
                                           unsigned long index )
 
741
                                      throw( DOMException, SVGException )
 
742
        {
 
743
        if (index > items.size())
 
744
            items.push_back(newItem);
 
745
        else
 
746
            {
 
747
            std::vector<SVGTransform>::iterator iter = items.begin() + index;
 
748
            items.insert(iter, newItem);
 
749
            }
 
750
        return newItem;
 
751
        }
 
752
 
 
753
    /**
 
754
     *
 
755
     */
 
756
    virtual SVGTransform replaceItem (const SVGTransform &newItem,
 
757
                                       unsigned long index )
 
758
                                throw( DOMException, SVGException )
 
759
        {
 
760
        if (index>=items.size())
 
761
            {
 
762
            SVGTransform transform;
 
763
            return transform;
 
764
            }
 
765
        else
 
766
            {
 
767
            std::vector<SVGTransform>::iterator iter = items.begin() + index;
 
768
            *iter = newItem;
 
769
            }
 
770
        return newItem;
 
771
        }
 
772
 
 
773
    /**
 
774
     *
 
775
     */
 
776
    virtual SVGTransform removeItem (unsigned long index )
 
777
                                     throw( DOMException )
 
778
        {
 
779
        if (index>=items.size())
 
780
            {
 
781
            SVGTransform transform;
 
782
            return transform;
 
783
            }
 
784
        std::vector<SVGTransform>::iterator iter = items.begin() + index;
 
785
        SVGTransform oldItem = *iter;
 
786
        items.erase(iter);
 
787
        return oldItem;
 
788
        }
 
789
 
 
790
    /**
 
791
     *
 
792
     */
 
793
    virtual SVGTransform appendItem (const SVGTransform &newItem)
 
794
                                  throw( DOMException, SVGException )
 
795
        {
 
796
        items.push_back(newItem);
 
797
        return newItem;
 
798
        }
 
799
 
 
800
    /**
 
801
     *
 
802
     */
 
803
    virtual SVGTransform createSVGTransformFromMatrix(const SVGMatrix &matrix)
 
804
        {
 
805
        SVGTransform transform;
 
806
        transform.setMatrix(matrix);
 
807
        return transform;
 
808
        }
 
809
 
 
810
    /**
 
811
     *
 
812
     */
 
813
    virtual SVGTransform consolidate()
 
814
        {
 
815
        SVGMatrix matrix;
 
816
        for (unsigned int i=0 ; i<items.size() ; i++)
 
817
            matrix = matrix.multiply(items[i].getMatrix());
 
818
        SVGTransform transform;
 
819
        transform.setMatrix(matrix);
 
820
        items.clear();
 
821
        items.push_back(transform);
 
822
        return transform;
 
823
        }
 
824
 
 
825
 
 
826
 
 
827
    //##################
 
828
    //# Non-API methods
 
829
    //##################
 
830
 
 
831
    /**
 
832
     *
 
833
     */
 
834
    SVGTransformList()
 
835
        {}
 
836
 
 
837
    /**
 
838
     *
 
839
     */
 
840
    SVGTransformList(const SVGTransformList &other)
 
841
        {
 
842
        items = other.items;
 
843
        }
 
844
 
 
845
    /**
 
846
     *
 
847
     */
 
848
    virtual ~SVGTransformList() {}
 
849
 
 
850
protected:
 
851
 
 
852
    std::vector<SVGTransform> items;
 
853
 
 
854
};
 
855
 
 
856
 
 
857
 
 
858
 
 
859
 
 
860
 
 
861
/*#########################################################################
 
862
## SVGAnimatedTransformList
 
863
#########################################################################*/
 
864
 
 
865
/**
 
866
 *
 
867
 */
 
868
class SVGAnimatedTransformList
 
869
{
 
870
public:
 
871
 
 
872
    /**
 
873
     *
 
874
     */
 
875
    virtual SVGTransformList getBaseVal()
 
876
        { return baseVal; }
 
877
 
 
878
    /**
 
879
     *
 
880
     */
 
881
    virtual SVGTransformList getAnimVal()
 
882
        { return animVal; }
 
883
 
 
884
 
 
885
 
 
886
    //##################
 
887
    //# Non-API methods
 
888
    //##################
 
889
 
 
890
    /**
 
891
     *
 
892
     */
 
893
    SVGAnimatedTransformList()
 
894
        {}
 
895
 
 
896
    /**
 
897
     *
 
898
     */
 
899
    SVGAnimatedTransformList(const SVGAnimatedTransformList &other)
 
900
        {
 
901
        baseVal = other.baseVal;
 
902
        animVal = other.animVal;
 
903
        }
 
904
 
 
905
    /**
 
906
     *
 
907
     */
 
908
    virtual ~SVGAnimatedTransformList() {}
 
909
 
 
910
protected:
 
911
 
 
912
    SVGTransformList baseVal;
 
913
    SVGTransformList animVal;
 
914
 
 
915
};
 
916
 
 
917
 
 
918
 
 
919
 
 
920
/*#########################################################################
 
921
## SVGAnimatedBoolean
 
922
#########################################################################*/
 
923
 
 
924
/**
 
925
 *
 
926
 */
 
927
class SVGAnimatedBoolean
 
928
{
 
929
public:
 
930
 
 
931
    /**
 
932
     *
 
933
     */
 
934
    virtual bool getBaseVal()
 
935
        {
 
936
        return baseVal;
 
937
        }
 
938
 
 
939
    /**
 
940
     *
 
941
     */
 
942
    virtual void setBaseVal(bool val) throw (DOMException)
 
943
        {
 
944
        baseVal = val;
 
945
        }
 
946
 
 
947
    /**
 
948
     *
 
949
     */
 
950
    virtual bool getAnimVal()
 
951
        {
 
952
        return animVal;
 
953
        }
 
954
 
 
955
 
 
956
    //##################
 
957
    //# Non-API methods
 
958
    //##################
 
959
 
 
960
    /**
 
961
     *
 
962
     */
 
963
    SVGAnimatedBoolean()
 
964
        {
 
965
        baseVal = animVal = false;
 
966
        }
 
967
 
 
968
    /**
 
969
     *
 
970
     */
 
971
    SVGAnimatedBoolean(const SVGAnimatedBoolean &other)
 
972
        {
 
973
        baseVal = other.baseVal;
 
974
        animVal = other.animVal;
 
975
        }
 
976
 
 
977
    /**
 
978
     *
 
979
     */
 
980
    virtual ~SVGAnimatedBoolean() {}
 
981
 
 
982
protected:
 
983
 
 
984
    bool baseVal, animVal;
 
985
 
 
986
};
 
987
 
 
988
 
 
989
 
 
990
 
 
991
/*#########################################################################
 
992
## SVGAnimatedString
 
993
#########################################################################*/
 
994
 
 
995
/**
 
996
 *
 
997
 */
 
998
class SVGAnimatedString
 
999
{
 
1000
public:
 
1001
 
 
1002
    /**
 
1003
     *
 
1004
     */
 
1005
    virtual DOMString getBaseVal()
 
1006
        {
 
1007
        return baseVal;
 
1008
        }
 
1009
 
 
1010
    /**
 
1011
     *
 
1012
     */
 
1013
    virtual void setBaseVal(const DOMString &val)
 
1014
                            throw (DOMException)
 
1015
        {
 
1016
        baseVal = val;
 
1017
        }
 
1018
 
 
1019
    /**
 
1020
     *
 
1021
     */
 
1022
    virtual DOMString getAnimVal()
 
1023
        {
 
1024
        return animVal;
 
1025
        }
 
1026
 
 
1027
 
 
1028
    //##################
 
1029
    //# Non-API methods
 
1030
    //##################
 
1031
 
 
1032
 
 
1033
    /**
 
1034
     *
 
1035
     */
 
1036
    SVGAnimatedString()
 
1037
        {
 
1038
        baseVal = "";
 
1039
        animVal = "";
 
1040
        }
 
1041
 
 
1042
    /**
 
1043
     *
 
1044
     */
 
1045
    SVGAnimatedString(const SVGAnimatedString &other)
 
1046
        {
 
1047
        baseVal = other.baseVal;
 
1048
        animVal = other.animVal;
 
1049
        }
 
1050
 
 
1051
    /**
 
1052
     *
 
1053
     */
 
1054
    virtual ~SVGAnimatedString() {}
 
1055
 
 
1056
protected:
 
1057
 
 
1058
    DOMString baseVal, animVal;
 
1059
 
 
1060
};
 
1061
 
 
1062
 
 
1063
 
 
1064
 
 
1065
 
 
1066
/*#########################################################################
 
1067
## SVGStringList
 
1068
#########################################################################*/
 
1069
 
 
1070
/**
 
1071
 *
 
1072
 */
 
1073
class SVGStringList
 
1074
{
 
1075
public:
 
1076
 
 
1077
 
 
1078
    /**
 
1079
     *
 
1080
     */
 
1081
    virtual unsigned long getNumberOfItems()
 
1082
        {
 
1083
        return items.size();
 
1084
        }
 
1085
 
 
1086
    /**
 
1087
     *
 
1088
     */
 
1089
    virtual void clear () throw( DOMException )
 
1090
       {
 
1091
       items.clear();
 
1092
       }
 
1093
 
 
1094
    /**
 
1095
     *
 
1096
     */
 
1097
    virtual DOMString initialize ( const DOMString& newItem )
 
1098
                    throw( DOMException, SVGException )
 
1099
        {
 
1100
        items.clear();
 
1101
        items.push_back(newItem);
 
1102
        return newItem;
 
1103
        }
 
1104
 
 
1105
    /**
 
1106
     *
 
1107
     */
 
1108
    virtual DOMString getItem ( unsigned long index )
 
1109
                    throw( DOMException )
 
1110
        {
 
1111
        if (index >= items.size())
 
1112
            return "";
 
1113
        return items[index];
 
1114
        }
 
1115
 
 
1116
    /**
 
1117
     *
 
1118
     */
 
1119
    virtual DOMString insertItemBefore ( const DOMString& newItem,
 
1120
                                 unsigned long index )
 
1121
                               throw( DOMException, SVGException )
 
1122
        {
 
1123
        if (index>=items.size())
 
1124
            {
 
1125
            items.push_back(newItem);
 
1126
            }
 
1127
        else
 
1128
            {
 
1129
            std::vector<DOMString>::iterator iter = items.begin() + index;
 
1130
            items.insert(iter, newItem);
 
1131
            }
 
1132
        return newItem;
 
1133
        }
 
1134
 
 
1135
    /**
 
1136
     *
 
1137
     */
 
1138
    virtual DOMString replaceItem ( const DOMString& newItem,
 
1139
                                    unsigned long index )
 
1140
                                throw( DOMException, SVGException )
 
1141
        {
 
1142
        if (index>=items.size())
 
1143
            return "";
 
1144
        std::vector<DOMString>::iterator iter = items.begin() + index;
 
1145
        *iter = newItem;
 
1146
        return newItem;
 
1147
        }
 
1148
 
 
1149
    /**
 
1150
     *
 
1151
     */
 
1152
    virtual DOMString removeItem ( unsigned long index )
 
1153
                    throw( DOMException )
 
1154
        {
 
1155
        if (index>=items.size())
 
1156
            return "";
 
1157
        std::vector<DOMString>::iterator iter = items.begin() + index;
 
1158
        DOMString oldstr = *iter;
 
1159
        items.erase(iter);
 
1160
        return oldstr;
 
1161
        }
 
1162
 
 
1163
    /**
 
1164
     *
 
1165
     */
 
1166
    virtual DOMString appendItem ( const DOMString& newItem )
 
1167
                    throw( DOMException, SVGException )
 
1168
        {
 
1169
        items.push_back(newItem);
 
1170
        return newItem;
 
1171
        }
 
1172
 
 
1173
 
 
1174
 
 
1175
    //##################
 
1176
    //# Non-API methods
 
1177
    //##################
 
1178
 
 
1179
    /**
 
1180
     *
 
1181
     */
 
1182
    SVGStringList() {}
 
1183
 
 
1184
    /**
 
1185
     *
 
1186
     */
 
1187
   SVGStringList(const SVGStringList &other)
 
1188
       {
 
1189
       items = other.items;
 
1190
       }
 
1191
 
 
1192
    /**
 
1193
     *
 
1194
     */
 
1195
    virtual ~SVGStringList() {}
 
1196
 
 
1197
protected:
 
1198
 
 
1199
    std::vector<DOMString>items;
 
1200
 
 
1201
};
 
1202
 
 
1203
 
 
1204
 
 
1205
 
 
1206
 
 
1207
/*#########################################################################
 
1208
## SVGAnimatedEnumeration
 
1209
#########################################################################*/
 
1210
 
 
1211
/**
 
1212
 *
 
1213
 */
 
1214
class SVGAnimatedEnumeration
 
1215
{
 
1216
public:
 
1217
 
 
1218
    /**
 
1219
     *
 
1220
     */
 
1221
    virtual unsigned short getBaseVal()
 
1222
        {
 
1223
        return baseVal;
 
1224
        }
 
1225
 
 
1226
    /**
 
1227
     *
 
1228
     */
 
1229
    virtual void setBaseVal(unsigned short val)
 
1230
                                     throw (DOMException)
 
1231
        {
 
1232
        baseVal = val;
 
1233
        }
 
1234
 
 
1235
    /**
 
1236
     *
 
1237
     */
 
1238
    virtual unsigned short getAnimVal()
 
1239
        {
 
1240
        return animVal;
 
1241
        }
 
1242
 
 
1243
 
 
1244
 
 
1245
    //##################
 
1246
    //# Non-API methods
 
1247
    //##################
 
1248
 
 
1249
 
 
1250
    /**
 
1251
     *
 
1252
     */
 
1253
    SVGAnimatedEnumeration()
 
1254
        {
 
1255
        baseVal = animVal = 0;
 
1256
        }
 
1257
 
 
1258
    /**
 
1259
     *
 
1260
     */
 
1261
    SVGAnimatedEnumeration(const SVGAnimatedEnumeration &other)
 
1262
        {
 
1263
        baseVal = other.baseVal;
 
1264
        animVal = other.animVal;
 
1265
        }
 
1266
 
 
1267
    /**
 
1268
     *
 
1269
     */
 
1270
    virtual ~SVGAnimatedEnumeration() {}
 
1271
 
 
1272
protected:
 
1273
 
 
1274
    int baseVal, animVal;
 
1275
 
 
1276
};
 
1277
 
 
1278
 
 
1279
 
 
1280
 
 
1281
 
 
1282
/*#########################################################################
 
1283
## SVGAnimatedInteger
 
1284
#########################################################################*/
 
1285
 
 
1286
/**
 
1287
 *
 
1288
 */
 
1289
class SVGAnimatedInteger
 
1290
{
 
1291
public:
 
1292
 
 
1293
 
 
1294
    /**
 
1295
     *
 
1296
     */
 
1297
    virtual long getBaseVal()
 
1298
        {
 
1299
        return baseVal;
 
1300
        }
 
1301
 
 
1302
    /**
 
1303
     *
 
1304
     */
 
1305
    virtual void setBaseVal(long val) throw (DOMException)
 
1306
        {
 
1307
        baseVal = val;
 
1308
        }
 
1309
 
 
1310
    /**
 
1311
     *
 
1312
     */
 
1313
    virtual long getAnimVal()
 
1314
        {
 
1315
        return animVal;
 
1316
        }
 
1317
 
 
1318
 
 
1319
 
 
1320
    //##################
 
1321
    //# Non-API methods
 
1322
    //##################
 
1323
 
 
1324
 
 
1325
    /**
 
1326
     *
 
1327
     */
 
1328
    SVGAnimatedInteger()
 
1329
        { baseVal = animVal = 0L;}
 
1330
 
 
1331
 
 
1332
    /**
 
1333
     *
 
1334
     */
 
1335
    SVGAnimatedInteger(long value)
 
1336
        {
 
1337
        baseVal = value;
 
1338
        animVal = 0L;
 
1339
        }
 
1340
 
 
1341
    /**
 
1342
     *
 
1343
     */
 
1344
    SVGAnimatedInteger(long baseValArg, long animValArg)
 
1345
        {
 
1346
        baseVal = baseValArg;
 
1347
        animVal = animValArg;
 
1348
        }
 
1349
 
 
1350
 
 
1351
    /**
 
1352
     *
 
1353
     */
 
1354
    SVGAnimatedInteger(const SVGAnimatedInteger &other)
 
1355
        {
 
1356
        baseVal = other.baseVal;
 
1357
        animVal = other.animVal;
 
1358
        }
 
1359
 
 
1360
    /**
 
1361
     *
 
1362
     */
 
1363
    virtual ~SVGAnimatedInteger() {}
 
1364
 
 
1365
protected:
 
1366
 
 
1367
    long baseVal, animVal;
 
1368
 
 
1369
};
 
1370
 
 
1371
 
 
1372
 
 
1373
 
 
1374
 
 
1375
/*#########################################################################
 
1376
## SVGNumber
 
1377
#########################################################################*/
 
1378
 
 
1379
/**
 
1380
 *
 
1381
 */
 
1382
class SVGNumber
 
1383
{
 
1384
public:
 
1385
 
 
1386
 
 
1387
    /**
 
1388
     *
 
1389
     */
 
1390
    virtual double getValue()
 
1391
        {
 
1392
        return value;
 
1393
        }
 
1394
 
 
1395
    /**
 
1396
     *
 
1397
     */
 
1398
    virtual void setValue(double val) throw (DOMException)
 
1399
        {
 
1400
        value = val;
 
1401
        }
 
1402
 
 
1403
 
 
1404
    //##################
 
1405
    //# Non-API methods
 
1406
    //##################
 
1407
 
 
1408
    /**
 
1409
     *
 
1410
     */
 
1411
    SVGNumber()
 
1412
        {
 
1413
        value = 0.0;
 
1414
        }
 
1415
 
 
1416
    /**
 
1417
     *
 
1418
     */
 
1419
    SVGNumber(const SVGNumber &other)
 
1420
        {
 
1421
        value = other.value;
 
1422
        }
 
1423
 
 
1424
    /**
 
1425
     *
 
1426
     */
 
1427
    virtual ~SVGNumber() {}
 
1428
 
 
1429
protected:
 
1430
 
 
1431
    double value;
 
1432
 
 
1433
};
 
1434
 
 
1435
 
 
1436
 
 
1437
 
 
1438
 
 
1439
/*#########################################################################
 
1440
## SVGAnimatedNumber
 
1441
#########################################################################*/
 
1442
 
 
1443
/**
 
1444
 *
 
1445
 */
 
1446
class SVGAnimatedNumber
 
1447
{
 
1448
public:
 
1449
 
 
1450
 
 
1451
 
 
1452
    /**
 
1453
     *
 
1454
     */
 
1455
    virtual double getBaseVal()
 
1456
        {
 
1457
        return baseVal;
 
1458
        }
 
1459
 
 
1460
    /**
 
1461
     *
 
1462
     */
 
1463
    virtual void setBaseVal(double val) throw (DOMException)
 
1464
        {
 
1465
        baseVal = val;
 
1466
        }
 
1467
 
 
1468
    /**
 
1469
     *
 
1470
     */
 
1471
    virtual double getAnimVal()
 
1472
        {
 
1473
        return animVal;
 
1474
        }
 
1475
 
 
1476
 
 
1477
 
 
1478
    //##################
 
1479
    //# Non-API methods
 
1480
    //##################
 
1481
 
 
1482
    /**
 
1483
     *
 
1484
     */
 
1485
    SVGAnimatedNumber()
 
1486
        {
 
1487
        baseVal = animVal = 0.0;
 
1488
        }
 
1489
 
 
1490
 
 
1491
    /**
 
1492
     *
 
1493
     */
 
1494
    SVGAnimatedNumber(double val)
 
1495
        {
 
1496
        baseVal = val;
 
1497
        animVal = 0.0;
 
1498
        }
 
1499
 
 
1500
 
 
1501
    /**
 
1502
     *
 
1503
     */
 
1504
    SVGAnimatedNumber(double baseValArg, double animValArg)
 
1505
        {
 
1506
        baseVal = baseValArg;
 
1507
        animVal = animValArg;
 
1508
        }
 
1509
 
 
1510
    /**
 
1511
     *
 
1512
     */
 
1513
    SVGAnimatedNumber(const SVGAnimatedNumber &other)
 
1514
        {
 
1515
        baseVal = other.baseVal;
 
1516
        animVal = other.animVal;
 
1517
        }
 
1518
 
 
1519
    /**
 
1520
     *
 
1521
     */
 
1522
    virtual ~SVGAnimatedNumber() {}
 
1523
 
 
1524
protected:
 
1525
 
 
1526
    double baseVal, animVal;
 
1527
 
 
1528
};
 
1529
 
 
1530
 
 
1531
 
 
1532
 
 
1533
 
 
1534
/*#########################################################################
 
1535
## SVGNumberList
 
1536
#########################################################################*/
 
1537
 
 
1538
/**
 
1539
 *
 
1540
 */
 
1541
class SVGNumberList
 
1542
{
 
1543
public:
 
1544
 
 
1545
    /**
 
1546
     *
 
1547
     */
 
1548
    virtual unsigned long getNumberOfItems()
 
1549
        {
 
1550
        return items.size();
 
1551
        }
 
1552
 
 
1553
 
 
1554
    /**
 
1555
     *
 
1556
     */
 
1557
    virtual void clear() throw( DOMException )
 
1558
        {
 
1559
        items.clear();
 
1560
        }
 
1561
 
 
1562
    /**
 
1563
     *
 
1564
     */
 
1565
    virtual SVGNumber initialize (const SVGNumber &newItem)
 
1566
                    throw( DOMException, SVGException )
 
1567
        {
 
1568
        items.clear();
 
1569
        items.push_back(newItem);
 
1570
        return newItem;
 
1571
        }
 
1572
 
 
1573
    /**
 
1574
     *
 
1575
     */
 
1576
    virtual SVGNumber getItem ( unsigned long index )
 
1577
                                  throw( DOMException )
 
1578
        {
 
1579
        if (index>=items.size())
 
1580
            {
 
1581
            SVGNumber num;
 
1582
            return num;
 
1583
            }
 
1584
        return items[index];
 
1585
        }
 
1586
 
 
1587
    /**
 
1588
     *
 
1589
     */
 
1590
    virtual SVGNumber insertItemBefore ( const SVGNumber &newItem,
 
1591
                                         unsigned long index )
 
1592
                                         throw( DOMException, SVGException )
 
1593
        {
 
1594
        if (index>=items.size())
 
1595
            {
 
1596
            items.push_back(newItem);
 
1597
            }
 
1598
        else
 
1599
            {
 
1600
            std::vector<SVGNumber>::iterator iter = items.begin() + index;
 
1601
            items.insert(iter, newItem);
 
1602
            }
 
1603
        return newItem;
 
1604
        }
 
1605
 
 
1606
    /**
 
1607
     *
 
1608
     */
 
1609
    virtual SVGNumber replaceItem ( const SVGNumber &newItem,
 
1610
                                    unsigned long index )
 
1611
                                    throw( DOMException, SVGException )
 
1612
        {
 
1613
        if (index>=items.size())
 
1614
            {
 
1615
            SVGNumber num;
 
1616
            return num;
 
1617
            }
 
1618
        std::vector<SVGNumber>::iterator iter = items.begin() + index;
 
1619
        *iter = newItem;
 
1620
        return newItem;
 
1621
        }
 
1622
 
 
1623
    /**
 
1624
     *
 
1625
     */
 
1626
    virtual SVGNumber removeItem ( unsigned long index )
 
1627
                                  throw( DOMException )
 
1628
        {
 
1629
        if (index>=items.size())
 
1630
            {
 
1631
            SVGNumber num;
 
1632
            return num;
 
1633
            }
 
1634
        std::vector<SVGNumber>::iterator iter = items.begin() + index;
 
1635
        SVGNumber oldval = *iter;
 
1636
        items.erase(iter);
 
1637
        return oldval;
 
1638
        }
 
1639
 
 
1640
    /**
 
1641
     *
 
1642
     */
 
1643
    virtual SVGNumber appendItem ( const SVGNumber &newItem )
 
1644
                                   throw( DOMException, SVGException )
 
1645
        {
 
1646
        items.push_back(newItem);
 
1647
        return newItem;
 
1648
        }
 
1649
 
 
1650
 
 
1651
    //##################
 
1652
    //# Non-API methods
 
1653
    //##################
 
1654
 
 
1655
    /**
 
1656
     *
 
1657
     */
 
1658
    SVGNumberList() {}
 
1659
 
 
1660
    /**
 
1661
     *
 
1662
     */
 
1663
    SVGNumberList(const SVGNumberList &other)
 
1664
        {
 
1665
        items = other.items;
 
1666
        }
 
1667
 
 
1668
    /**
 
1669
     *
 
1670
     */
 
1671
    virtual ~SVGNumberList() {}
 
1672
 
 
1673
protected:
 
1674
 
 
1675
    std::vector<SVGNumber>items;
 
1676
 
 
1677
};
 
1678
 
 
1679
 
 
1680
 
 
1681
 
 
1682
 
 
1683
/*#########################################################################
 
1684
## SVGAnimatedNumberList
 
1685
#########################################################################*/
 
1686
 
 
1687
/**
 
1688
 *
 
1689
 */
 
1690
class SVGAnimatedNumberList
 
1691
{
 
1692
public:
 
1693
 
 
1694
 
 
1695
    /**
 
1696
     *
 
1697
     */
 
1698
    virtual SVGNumberList &getBaseVal()
 
1699
        {
 
1700
        return baseVal;
 
1701
        }
 
1702
 
 
1703
    /**
 
1704
     *
 
1705
     */
 
1706
    virtual SVGNumberList &getAnimVal()
 
1707
        {
 
1708
        return animVal;
 
1709
        }
 
1710
 
 
1711
 
 
1712
 
 
1713
    //##################
 
1714
    //# Non-API methods
 
1715
    //##################
 
1716
 
 
1717
    /**
 
1718
     *
 
1719
     */
 
1720
    SVGAnimatedNumberList() {}
 
1721
 
 
1722
    /**
 
1723
     *
 
1724
     */
 
1725
    SVGAnimatedNumberList(const SVGAnimatedNumberList &other)
 
1726
        {
 
1727
        baseVal = other.baseVal;
 
1728
        animVal = other.animVal;
 
1729
        }
 
1730
 
 
1731
    /**
 
1732
     *
 
1733
     */
 
1734
    virtual ~SVGAnimatedNumberList() {}
 
1735
 
 
1736
protected:
 
1737
 
 
1738
    SVGNumberList baseVal;
 
1739
    SVGNumberList animVal;
 
1740
 
 
1741
};
 
1742
 
 
1743
 
 
1744
 
 
1745
 
 
1746
 
 
1747
 
 
1748
/*#########################################################################
 
1749
## SVGLength
 
1750
#########################################################################*/
 
1751
 
 
1752
/**
 
1753
 *
 
1754
 */
 
1755
class SVGLength
 
1756
{
 
1757
public:
 
1758
 
 
1759
    /**
 
1760
     * Length Unit Types
 
1761
     */
 
1762
    typedef enum
 
1763
        {
 
1764
        SVG_LENGTHTYPE_UNKNOWN    = 0,
 
1765
        SVG_LENGTHTYPE_NUMBER     = 1,
 
1766
        SVG_LENGTHTYPE_PERCENTAGE = 2,
 
1767
        SVG_LENGTHTYPE_EMS        = 3,
 
1768
        SVG_LENGTHTYPE_EXS        = 4,
 
1769
        SVG_LENGTHTYPE_PX         = 5,
 
1770
        SVG_LENGTHTYPE_CM         = 6,
 
1771
        SVG_LENGTHTYPE_MM         = 7,
 
1772
        SVG_LENGTHTYPE_IN         = 8,
 
1773
        SVG_LENGTHTYPE_PT         = 9,
 
1774
        SVG_LENGTHTYPE_PC         = 10
 
1775
        } LengthUnitType;
 
1776
 
 
1777
 
 
1778
    /**
 
1779
     *
 
1780
     */
 
1781
    virtual unsigned short getUnitType( )
 
1782
        {
 
1783
        return unitType;
 
1784
        }
 
1785
 
 
1786
    /**
 
1787
     *
 
1788
     */
 
1789
    virtual double getValue( )
 
1790
        {
 
1791
        return value;
 
1792
        }
 
1793
 
 
1794
    /**
 
1795
     *
 
1796
     */
 
1797
    virtual void setValue( double val )  throw (DOMException)
 
1798
        {
 
1799
        value = val;
 
1800
        }
 
1801
 
 
1802
    /**
 
1803
     *
 
1804
     */
 
1805
    virtual double getValueInSpecifiedUnits( )
 
1806
        {
 
1807
        double result = 0.0;
 
1808
        //fill this in
 
1809
        return result;
 
1810
        }
 
1811
 
 
1812
    /**
 
1813
     *
 
1814
     */
 
1815
    virtual void setValueInSpecifiedUnits( double /*val*/ )
 
1816
                                           throw (DOMException)
 
1817
        {
 
1818
        //fill this in
 
1819
        }
 
1820
 
 
1821
    /**
 
1822
     *
 
1823
     */
 
1824
    virtual DOMString getValueAsString( )
 
1825
        {
 
1826
        DOMString ret;
 
1827
        char buf[32];
 
1828
        snprintf(buf, 31, "%f", value);
 
1829
        ret.append(buf);
 
1830
        return ret;
 
1831
        }
 
1832
 
 
1833
    /**
 
1834
     *
 
1835
     */
 
1836
    virtual void setValueAsString( const DOMString& /*val*/ )
 
1837
                                   throw (DOMException)
 
1838
        {
 
1839
        }
 
1840
 
 
1841
 
 
1842
    /**
 
1843
     *
 
1844
     */
 
1845
    virtual void newValueSpecifiedUnits ( unsigned short /*unitType*/, double /*val*/ )
 
1846
        {
 
1847
        }
 
1848
 
 
1849
    /**
 
1850
     *
 
1851
     */
 
1852
    virtual void convertToSpecifiedUnits ( unsigned short /*unitType*/ )
 
1853
        {
 
1854
        }
 
1855
 
 
1856
 
 
1857
 
 
1858
    //##################
 
1859
    //# Non-API methods
 
1860
    //##################
 
1861
 
 
1862
    /**
 
1863
     *
 
1864
     */
 
1865
    SVGLength()
 
1866
        {
 
1867
        unitType = SVG_LENGTHTYPE_UNKNOWN;
 
1868
        value    = 0.0;
 
1869
        }
 
1870
 
 
1871
 
 
1872
    /**
 
1873
     *
 
1874
     */
 
1875
    SVGLength(const SVGLength &other)
 
1876
        {
 
1877
        unitType  = other.unitType;
 
1878
        value     = other.value;
 
1879
        }
 
1880
 
 
1881
    /**
 
1882
     *
 
1883
     */
 
1884
    virtual ~SVGLength() {}
 
1885
 
 
1886
protected:
 
1887
 
 
1888
    int unitType;
 
1889
 
 
1890
    double value;
 
1891
 
 
1892
};
 
1893
 
 
1894
 
 
1895
 
 
1896
 
 
1897
 
 
1898
 
 
1899
/*#########################################################################
 
1900
## SVGAnimatedLength
 
1901
#########################################################################*/
 
1902
 
 
1903
/**
 
1904
 *
 
1905
 */
 
1906
class SVGAnimatedLength
 
1907
{
 
1908
public:
 
1909
 
 
1910
    /**
 
1911
     *
 
1912
     */
 
1913
    virtual SVGLength &getBaseVal()
 
1914
        {
 
1915
        return baseVal;
 
1916
        }
 
1917
 
 
1918
    /**
 
1919
     *
 
1920
     */
 
1921
    virtual SVGLength &getAnimVal()
 
1922
        {
 
1923
        return animVal;
 
1924
        }
 
1925
 
 
1926
 
 
1927
 
 
1928
    //##################
 
1929
    //# Non-API methods
 
1930
    //##################
 
1931
 
 
1932
    /**
 
1933
     *
 
1934
     */
 
1935
    SVGAnimatedLength() {}
 
1936
 
 
1937
    /**
 
1938
     *
 
1939
     */
 
1940
    SVGAnimatedLength(const SVGAnimatedLength &other)
 
1941
        {
 
1942
        baseVal = other.baseVal;
 
1943
        animVal = other.animVal;
 
1944
        }
 
1945
 
 
1946
    /**
 
1947
     *
 
1948
     */
 
1949
    virtual ~SVGAnimatedLength() {}
 
1950
 
 
1951
protected:
 
1952
 
 
1953
    SVGLength baseVal, animVal;
 
1954
 
 
1955
};
 
1956
 
 
1957
 
 
1958
 
 
1959
 
 
1960
 
 
1961
 
 
1962
/*#########################################################################
 
1963
## SVGLengthList
 
1964
#########################################################################*/
 
1965
 
 
1966
/**
 
1967
 *
 
1968
 */
 
1969
class SVGLengthList
 
1970
{
 
1971
public:
 
1972
 
 
1973
    /**
 
1974
     *
 
1975
     */
 
1976
    virtual unsigned long getNumberOfItems()
 
1977
        {
 
1978
        return items.size();
 
1979
        }
 
1980
 
 
1981
 
 
1982
    /**
 
1983
     *
 
1984
     */
 
1985
    virtual void clear (  ) throw( DOMException )
 
1986
        {
 
1987
        items.clear();
 
1988
        }
 
1989
 
 
1990
    /**
 
1991
     *
 
1992
     */
 
1993
    virtual SVGLength initialize (const SVGLength &newItem )
 
1994
                    throw( DOMException, SVGException )
 
1995
        {
 
1996
        items.clear();
 
1997
        items.push_back(newItem);
 
1998
        return newItem;
 
1999
        }
 
2000
 
 
2001
    /**
 
2002
     *
 
2003
     */
 
2004
    virtual SVGLength getItem (unsigned long index)
 
2005
                    throw( DOMException )
 
2006
        {
 
2007
        if (index>=items.size())
 
2008
            {
 
2009
            SVGLength ret;
 
2010
            return ret;
 
2011
            }
 
2012
        return items[index];
 
2013
        }
 
2014
 
 
2015
    /**
 
2016
     *
 
2017
     */
 
2018
    virtual SVGLength insertItemBefore (const SVGLength &newItem,
 
2019
                                         unsigned long index )
 
2020
                                   throw( DOMException, SVGException )
 
2021
        {
 
2022
        if (index>=items.size())
 
2023
            {
 
2024
            items.push_back(newItem);
 
2025
            }
 
2026
        else
 
2027
            {
 
2028
            std::vector<SVGLength>::iterator iter = items.begin() + index;
 
2029
            items.insert(iter, newItem);
 
2030
            }
 
2031
        return newItem;
 
2032
        }
 
2033
 
 
2034
    /**
 
2035
     *
 
2036
     */
 
2037
    virtual SVGLength replaceItem (const SVGLength &newItem,
 
2038
                                    unsigned long index )
 
2039
                               throw( DOMException, SVGException )
 
2040
        {
 
2041
        if (index>=items.size())
 
2042
            {
 
2043
            SVGLength ret;
 
2044
            return ret;
 
2045
            }
 
2046
        std::vector<SVGLength>::iterator iter = items.begin() + index;
 
2047
        *iter = newItem;
 
2048
        return newItem;
 
2049
        }
 
2050
 
 
2051
    /**
 
2052
     *
 
2053
     */
 
2054
    virtual SVGLength removeItem (unsigned long index )
 
2055
                    throw( DOMException )
 
2056
        {
 
2057
        if (index>=items.size())
 
2058
            {
 
2059
            SVGLength ret;
 
2060
            return ret;
 
2061
            }
 
2062
        std::vector<SVGLength>::iterator iter = items.begin() + index;
 
2063
        SVGLength oldval = *iter;
 
2064
        items.erase(iter);
 
2065
        return oldval;
 
2066
        }
 
2067
 
 
2068
    /**
 
2069
     *
 
2070
     */
 
2071
    virtual SVGLength appendItem (const SVGLength &newItem )
 
2072
                    throw( DOMException, SVGException )
 
2073
        {
 
2074
        items.push_back(newItem);
 
2075
        return newItem;
 
2076
        }
 
2077
 
 
2078
 
 
2079
    //##################
 
2080
    //# Non-API methods
 
2081
    //##################
 
2082
 
 
2083
    /**
 
2084
     *
 
2085
     */
 
2086
    SVGLengthList() {}
 
2087
 
 
2088
    /**
 
2089
     *
 
2090
     */
 
2091
    SVGLengthList(const SVGLengthList &other)
 
2092
        {
 
2093
        items = other.items;
 
2094
        }
 
2095
 
 
2096
    /**
 
2097
     *
 
2098
     */
 
2099
    virtual ~SVGLengthList() {}
 
2100
 
 
2101
protected:
 
2102
 
 
2103
    std::vector<SVGLength>items;
 
2104
 
 
2105
};
 
2106
 
 
2107
 
 
2108
 
 
2109
 
 
2110
 
 
2111
 
 
2112
/*#########################################################################
 
2113
## SVGAnimatedLengthList
 
2114
#########################################################################*/
 
2115
 
 
2116
/**
 
2117
 *
 
2118
 */
 
2119
class SVGAnimatedLengthList
 
2120
{
 
2121
public:
 
2122
 
 
2123
    /**
 
2124
     *
 
2125
     */
 
2126
    virtual SVGLengthList &getBaseVal()
 
2127
        {
 
2128
        return baseVal;
 
2129
        }
 
2130
 
 
2131
    /**
 
2132
     *
 
2133
     */
 
2134
    virtual SVGLengthList &getAnimVal()
 
2135
        {
 
2136
        return animVal;
 
2137
        }
 
2138
 
 
2139
 
 
2140
 
 
2141
    //##################
 
2142
    //# Non-API methods
 
2143
    //##################
 
2144
 
 
2145
    /**
 
2146
     *
 
2147
     */
 
2148
    SVGAnimatedLengthList() {}
 
2149
 
 
2150
    /**
 
2151
     *
 
2152
     */
 
2153
   SVGAnimatedLengthList(const SVGAnimatedLengthList &other)
 
2154
        {
 
2155
        baseVal = other.baseVal;
 
2156
        animVal = other.animVal;
 
2157
        }
 
2158
 
 
2159
    /**
 
2160
     *
 
2161
     */
 
2162
    virtual ~SVGAnimatedLengthList() {}
 
2163
 
 
2164
protected:
 
2165
 
 
2166
    SVGLengthList baseVal, animVal;
 
2167
 
 
2168
};
 
2169
 
 
2170
 
 
2171
 
 
2172
 
 
2173
 
 
2174
 
 
2175
/*#########################################################################
 
2176
## SVGAngle
 
2177
#########################################################################*/
 
2178
 
 
2179
/**
 
2180
 *
 
2181
 */
 
2182
class SVGAngle
 
2183
{
 
2184
public:
 
2185
 
 
2186
    /**
 
2187
     *  Angle Unit Types
 
2188
     */
 
2189
    typedef enum
 
2190
        {
 
2191
        SVG_ANGLETYPE_UNKNOWN     = 0,
 
2192
        SVG_ANGLETYPE_UNSPECIFIED = 1,
 
2193
        SVG_ANGLETYPE_DEG         = 2,
 
2194
        SVG_ANGLETYPE_RAD         = 3,
 
2195
        SVG_ANGLETYPE_GRAD        = 4
 
2196
        } AngleUnitType;
 
2197
 
 
2198
 
 
2199
 
 
2200
    /**
 
2201
     *
 
2202
     */
 
2203
    virtual unsigned short getUnitType()
 
2204
        {
 
2205
        return unitType;
 
2206
        }
 
2207
 
 
2208
    /**
 
2209
     *
 
2210
     */
 
2211
    virtual double getValue()
 
2212
        {
 
2213
        return value;
 
2214
        }
 
2215
 
 
2216
    /**
 
2217
     *
 
2218
     */
 
2219
    virtual void setValue(double val) throw (DOMException)
 
2220
        {
 
2221
        value = val;
 
2222
        }
 
2223
 
 
2224
    /**
 
2225
     *
 
2226
     */
 
2227
    virtual double getValueInSpecifiedUnits()
 
2228
        {
 
2229
        double result = 0.0;
 
2230
        //convert here
 
2231
        return result;
 
2232
        }
 
2233
 
 
2234
    /**
 
2235
     *
 
2236
     */
 
2237
    virtual void setValueInSpecifiedUnits(double /*val*/)
 
2238
                                     throw (DOMException)
 
2239
        {
 
2240
        //do conversion
 
2241
        }
 
2242
 
 
2243
    /**
 
2244
     *
 
2245
     */
 
2246
    virtual DOMString getValueAsString()
 
2247
        {
 
2248
        DOMString result;
 
2249
        char buf[32];
 
2250
        snprintf(buf, 31, "%f", value);
 
2251
        result.append(buf);
 
2252
        return result;
 
2253
        }
 
2254
 
 
2255
    /**
 
2256
     *
 
2257
     */
 
2258
    virtual void setValueAsString(const DOMString &/*val*/)
 
2259
                                  throw (DOMException)
 
2260
        {
 
2261
        //convert here
 
2262
        }
 
2263
 
 
2264
 
 
2265
    /**
 
2266
     *
 
2267
     */
 
2268
    virtual void newValueSpecifiedUnits (unsigned short /*unitType*/,
 
2269
                                         double /*valueInSpecifiedUnits*/ )
 
2270
        {
 
2271
        //convert here
 
2272
        }
 
2273
 
 
2274
    /**
 
2275
     *
 
2276
     */
 
2277
    virtual void convertToSpecifiedUnits (unsigned short /*unitType*/ )
 
2278
        {
 
2279
        //convert here
 
2280
        }
 
2281
 
 
2282
 
 
2283
 
 
2284
    //##################
 
2285
    //# Non-API methods
 
2286
    //##################
 
2287
 
 
2288
    /**
 
2289
     *
 
2290
     */
 
2291
    SVGAngle()
 
2292
        {
 
2293
        unitType = SVG_ANGLETYPE_UNKNOWN;
 
2294
        value    = 0.0;
 
2295
        }
 
2296
 
 
2297
    /**
 
2298
     *
 
2299
     */
 
2300
    SVGAngle(const SVGAngle &other)
 
2301
        {
 
2302
        unitType = other.unitType;
 
2303
        value    = other.value;
 
2304
        }
 
2305
 
 
2306
    /**
 
2307
     *
 
2308
     */
 
2309
    virtual ~SVGAngle() {}
 
2310
 
 
2311
protected:
 
2312
 
 
2313
    int unitType;
 
2314
 
 
2315
    double value;
 
2316
 
 
2317
};
 
2318
 
 
2319
 
 
2320
 
 
2321
 
 
2322
 
 
2323
 
 
2324
/*#########################################################################
 
2325
## SVGAnimatedAngle
 
2326
#########################################################################*/
 
2327
 
 
2328
/**
 
2329
 *
 
2330
 */
 
2331
class SVGAnimatedAngle
 
2332
{
 
2333
public:
 
2334
 
 
2335
    /**
 
2336
     *
 
2337
     */
 
2338
    virtual SVGAngle getBaseVal()
 
2339
        {
 
2340
        return baseVal;
 
2341
        }
 
2342
 
 
2343
    /**
 
2344
     *
 
2345
     */
 
2346
    virtual SVGAngle getAnimVal()
 
2347
        {
 
2348
        return animVal;
 
2349
        }
 
2350
 
 
2351
    //##################
 
2352
    //# Non-API methods
 
2353
    //##################
 
2354
 
 
2355
    /**
 
2356
     *
 
2357
     */
 
2358
    SVGAnimatedAngle() {}
 
2359
 
 
2360
    /**
 
2361
     *
 
2362
     */
 
2363
    SVGAnimatedAngle(const SVGAngle &angle)
 
2364
        { baseVal = angle; }
 
2365
 
 
2366
    /**
 
2367
     *
 
2368
     */
 
2369
    SVGAnimatedAngle(const SVGAnimatedAngle &other)
 
2370
        {
 
2371
        baseVal = other.baseVal;
 
2372
        animVal = other.animVal;
 
2373
        }
 
2374
 
 
2375
    /**
 
2376
     *
 
2377
     */
 
2378
    virtual ~SVGAnimatedAngle() {}
 
2379
 
 
2380
protected:
 
2381
 
 
2382
    SVGAngle baseVal, animVal;
 
2383
 
 
2384
};
 
2385
 
 
2386
 
 
2387
 
 
2388
 
 
2389
 
 
2390
 
 
2391
/*#########################################################################
 
2392
## SVGICCColor
 
2393
#########################################################################*/
 
2394
 
 
2395
/**
 
2396
 *
 
2397
 */
 
2398
class SVGICCColor
 
2399
{
 
2400
public:
 
2401
 
 
2402
    /**
 
2403
     *
 
2404
     */
 
2405
    virtual DOMString getColorProfile()
 
2406
        {
 
2407
        return colorProfile;
 
2408
        }
 
2409
 
 
2410
    /**
 
2411
     *
 
2412
     */
 
2413
    virtual void setColorProfile(const DOMString &val) throw (DOMException)
 
2414
        {
 
2415
        colorProfile = val;
 
2416
        }
 
2417
 
 
2418
    /**
 
2419
     *
 
2420
     */
 
2421
    virtual SVGNumberList &getColors()
 
2422
        {
 
2423
        return colors;
 
2424
        }
 
2425
 
 
2426
 
 
2427
 
 
2428
    //##################
 
2429
    //# Non-API methods
 
2430
    //##################
 
2431
 
 
2432
    /**
 
2433
     *
 
2434
     */
 
2435
    SVGICCColor() {}
 
2436
 
 
2437
    /**
 
2438
     *
 
2439
     */
 
2440
    SVGICCColor(const SVGICCColor &other)
 
2441
        {
 
2442
        colorProfile = other.colorProfile;
 
2443
        colors       = other.colors;
 
2444
        }
 
2445
 
 
2446
    /**
 
2447
     *
 
2448
     */
 
2449
    virtual ~SVGICCColor() {}
 
2450
 
 
2451
protected:
 
2452
 
 
2453
    DOMString colorProfile;
 
2454
 
 
2455
    SVGNumberList colors;
 
2456
 
 
2457
};
 
2458
 
 
2459
 
 
2460
/*#########################################################################
 
2461
## SVGColor
 
2462
#########################################################################*/
 
2463
 
 
2464
/**
 
2465
 *
 
2466
 */
 
2467
class SVGColor : virtual public css::CSSValue
 
2468
{
 
2469
public:
 
2470
 
 
2471
 
 
2472
    /**
 
2473
     * Color Types
 
2474
     */
 
2475
    typedef enum
 
2476
        {
 
2477
        SVG_COLORTYPE_UNKNOWN           = 0,
 
2478
        SVG_COLORTYPE_RGBCOLOR          = 1,
 
2479
        SVG_COLORTYPE_RGBCOLOR_ICCCOLOR = 2,
 
2480
        SVG_COLORTYPE_CURRENTCOLOR      = 3
 
2481
        } ColorType;
 
2482
 
 
2483
 
 
2484
    /**
 
2485
     *
 
2486
     */
 
2487
    virtual unsigned short getColorType()
 
2488
        {
 
2489
        return colorType;
 
2490
        }
 
2491
 
 
2492
    /**
 
2493
     *
 
2494
     */
 
2495
    virtual css::RGBColor getRgbColor()
 
2496
        {
 
2497
        css::RGBColor col;
 
2498
        return col;
 
2499
        }
 
2500
 
 
2501
    /**
 
2502
     *
 
2503
     */
 
2504
    virtual SVGICCColor getIccColor()
 
2505
        {
 
2506
        SVGICCColor col;
 
2507
        return col;
 
2508
        }
 
2509
 
 
2510
 
 
2511
    /**
 
2512
     *
 
2513
     */
 
2514
    virtual void setRGBColor (const DOMString& /*rgbColor*/ )
 
2515
                              throw( SVGException )
 
2516
        {
 
2517
        }
 
2518
 
 
2519
    /**
 
2520
     *
 
2521
     */
 
2522
    virtual void setRGBColorICCColor (const DOMString& /*rgbColor*/,
 
2523
                                      const DOMString& /*iccColor*/ )
 
2524
                                      throw( SVGException )
 
2525
        {
 
2526
        }
 
2527
 
 
2528
    /**
 
2529
     *
 
2530
     */
 
2531
    virtual void setColor (unsigned short /*colorType*/,
 
2532
                           const DOMString& /*rgbColor*/,
 
2533
                           const DOMString& /*iccColor*/ )
 
2534
                           throw( SVGException )
 
2535
        {
 
2536
        }
 
2537
 
 
2538
 
 
2539
 
 
2540
    //##################
 
2541
    //# Non-API methods
 
2542
    //##################
 
2543
 
 
2544
    /**
 
2545
     *
 
2546
     */
 
2547
    SVGColor()
 
2548
        {
 
2549
        colorType = SVG_COLORTYPE_UNKNOWN;
 
2550
        }
 
2551
 
 
2552
    /**
 
2553
     *
 
2554
     */
 
2555
    SVGColor(const SVGColor &other) : css::CSSValue(other)
 
2556
        {
 
2557
        colorType = other.colorType;
 
2558
        }
 
2559
 
 
2560
    /**
 
2561
     *
 
2562
     */
 
2563
    virtual ~SVGColor() {}
 
2564
 
 
2565
protected:
 
2566
 
 
2567
    int colorType;
 
2568
 
 
2569
};
 
2570
 
 
2571
 
 
2572
 
 
2573
 
 
2574
 
 
2575
 
 
2576
 
 
2577
 
 
2578
 
 
2579
 
 
2580
/*#########################################################################
 
2581
## SVGRect
 
2582
#########################################################################*/
 
2583
 
 
2584
/**
 
2585
 *
 
2586
 */
 
2587
class SVGRect
 
2588
{
 
2589
public:
 
2590
 
 
2591
    /**
 
2592
     *
 
2593
     */
 
2594
    virtual double getX()
 
2595
        {
 
2596
        return x;
 
2597
        }
 
2598
 
 
2599
    /**
 
2600
     *
 
2601
     */
 
2602
    virtual void setX(double val) throw (DOMException)
 
2603
        {
 
2604
        x = val;
 
2605
        }
 
2606
 
 
2607
    /**
 
2608
     *
 
2609
     */
 
2610
    virtual double getY()
 
2611
        {
 
2612
        return y;
 
2613
        }
 
2614
 
 
2615
    /**
 
2616
     *
 
2617
     */
 
2618
    virtual void setY(double val) throw (DOMException)
 
2619
        {
 
2620
        y = val;
 
2621
        }
 
2622
 
 
2623
    /**
 
2624
     *
 
2625
     */
 
2626
    virtual double getWidth()
 
2627
        {
 
2628
        return width;
 
2629
        }
 
2630
 
 
2631
    /**
 
2632
     *
 
2633
     */
 
2634
    virtual void setWidth(double val) throw (DOMException)
 
2635
        {
 
2636
        width = val;
 
2637
        }
 
2638
 
 
2639
    /**
 
2640
     *
 
2641
     */
 
2642
    virtual double getHeight()
 
2643
        {
 
2644
        return height;
 
2645
        }
 
2646
 
 
2647
    /**
 
2648
     *
 
2649
     */
 
2650
    virtual void setHeight(double val) throw (DOMException)
 
2651
        {
 
2652
        height = val;
 
2653
        }
 
2654
 
 
2655
 
 
2656
    //##################
 
2657
    //# Non-API methods
 
2658
    //##################
 
2659
 
 
2660
    /**
 
2661
     *
 
2662
     */
 
2663
    SVGRect()
 
2664
        {
 
2665
        x = y = width = height = 0.0;
 
2666
        }
 
2667
 
 
2668
    /**
 
2669
     *
 
2670
     */
 
2671
    SVGRect(const SVGRect &other)
 
2672
        {
 
2673
        x = other.x;
 
2674
        y = other.y;
 
2675
        width = other.width;
 
2676
        height = other.height;
 
2677
        }
 
2678
 
 
2679
    /**
 
2680
     *
 
2681
     */
 
2682
    virtual ~SVGRect() {}
 
2683
 
 
2684
protected:
 
2685
 
 
2686
    double x, y, width, height;
 
2687
 
 
2688
};
 
2689
 
 
2690
 
 
2691
 
 
2692
 
 
2693
 
 
2694
 
 
2695
/*#########################################################################
 
2696
## SVGAnimatedRect
 
2697
#########################################################################*/
 
2698
 
 
2699
/**
 
2700
 *
 
2701
 */
 
2702
class SVGAnimatedRect
 
2703
{
 
2704
public:
 
2705
 
 
2706
    /**
 
2707
     *
 
2708
     */
 
2709
    virtual SVGRect &getBaseVal()
 
2710
        {
 
2711
        return baseVal;
 
2712
        }
 
2713
 
 
2714
    /**
 
2715
     *
 
2716
     */
 
2717
    virtual SVGRect &getAnimVal()
 
2718
        {
 
2719
        return animVal;
 
2720
        }
 
2721
 
 
2722
 
 
2723
 
 
2724
    //##################
 
2725
    //# Non-API methods
 
2726
    //##################
 
2727
 
 
2728
    /**
 
2729
     *
 
2730
     */
 
2731
    SVGAnimatedRect()
 
2732
        {
 
2733
        }
 
2734
 
 
2735
    /**
 
2736
     *
 
2737
     */
 
2738
    SVGAnimatedRect(const SVGAnimatedRect &other)
 
2739
        {
 
2740
        baseVal = other.baseVal;
 
2741
        animVal = other.animVal;
 
2742
        }
 
2743
 
 
2744
    /**
 
2745
     *
 
2746
     */
 
2747
    virtual ~SVGAnimatedRect() {}
 
2748
 
 
2749
protected:
 
2750
 
 
2751
    SVGRect baseVal, animVal;
 
2752
 
 
2753
};
 
2754
 
 
2755
 
 
2756
 
 
2757
/*#########################################################################
 
2758
## SVGPoint
 
2759
#########################################################################*/
 
2760
 
 
2761
/**
 
2762
 *
 
2763
 */
 
2764
class SVGPoint
 
2765
{
 
2766
public:
 
2767
 
 
2768
 
 
2769
 
 
2770
    /**
 
2771
     *
 
2772
     */
 
2773
    virtual double getX()
 
2774
        { return x; }
 
2775
 
 
2776
    /**
 
2777
     *
 
2778
     */
 
2779
    virtual void setX(double val) throw (DOMException)
 
2780
        { x = val; }
 
2781
 
 
2782
    /**
 
2783
     *
 
2784
     */
 
2785
    virtual double getY()
 
2786
        { return y; }
 
2787
 
 
2788
    /**
 
2789
     *
 
2790
     */
 
2791
    virtual void setY(double val) throw (DOMException)
 
2792
        { y = val; }
 
2793
 
 
2794
    /**
 
2795
     *
 
2796
     */
 
2797
    virtual SVGPoint matrixTransform(const SVGMatrix &/*matrix*/)
 
2798
        {
 
2799
        SVGPoint point;
 
2800
        return point;
 
2801
        }
 
2802
 
 
2803
 
 
2804
 
 
2805
    //##################
 
2806
    //# Non-API methods
 
2807
    //##################
 
2808
 
 
2809
    /**
 
2810
     *
 
2811
     */
 
2812
    SVGPoint()
 
2813
        { x = y = 0; }
 
2814
 
 
2815
    /**
 
2816
     *
 
2817
     */
 
2818
    SVGPoint(const SVGPoint &other)
 
2819
        {
 
2820
        x = other.x;
 
2821
        y = other.y;
 
2822
        }
 
2823
 
 
2824
    /**
 
2825
     *
 
2826
     */
 
2827
    virtual ~SVGPoint() {}
 
2828
 
 
2829
protected:
 
2830
 
 
2831
    double x, y;
 
2832
};
 
2833
 
 
2834
 
 
2835
 
 
2836
 
 
2837
 
 
2838
 
 
2839
/*#########################################################################
 
2840
## SVGPointList
 
2841
#########################################################################*/
 
2842
 
 
2843
/**
 
2844
 *
 
2845
 */
 
2846
class SVGPointList
 
2847
{
 
2848
public:
 
2849
 
 
2850
    /**
 
2851
     *
 
2852
     */
 
2853
    virtual unsigned long getNumberOfItems()
 
2854
        { return items.size(); }
 
2855
 
 
2856
    /**
 
2857
     *
 
2858
     */
 
2859
    virtual void clear() throw( DOMException )
 
2860
        { items.clear(); }
 
2861
 
 
2862
    /**
 
2863
     *
 
2864
     */
 
2865
    virtual SVGPoint initialize(const SVGPoint &newItem)
 
2866
                             throw( DOMException, SVGException )
 
2867
        {
 
2868
        items.clear();
 
2869
        items.push_back(newItem);
 
2870
        return newItem;
 
2871
        }
 
2872
 
 
2873
    /**
 
2874
     *
 
2875
     */
 
2876
    virtual SVGPoint getItem(unsigned long index )
 
2877
                             throw( DOMException )
 
2878
        {
 
2879
        if (index >= items.size())
 
2880
            {
 
2881
            SVGPoint point;
 
2882
            return point;
 
2883
            }
 
2884
        return items[index];
 
2885
        }
 
2886
 
 
2887
    /**
 
2888
     *
 
2889
     */
 
2890
    virtual SVGPoint insertItemBefore(const SVGPoint &newItem,
 
2891
                                      unsigned long index )
 
2892
                                      throw( DOMException, SVGException )
 
2893
        {
 
2894
        if (index >= items.size())
 
2895
            items.push_back(newItem);
 
2896
        else
 
2897
            {
 
2898
            std::vector<SVGPoint>::iterator iter = items.begin() + index;
 
2899
            items.insert(iter, newItem);
 
2900
            }
 
2901
        return newItem;
 
2902
        }
 
2903
 
 
2904
    /**
 
2905
     *
 
2906
     */
 
2907
    virtual SVGPoint replaceItem(const SVGPoint &newItem,
 
2908
                                  unsigned long index )
 
2909
                                  throw( DOMException, SVGException )
 
2910
        {
 
2911
        if (index >= items.size())
 
2912
            {
 
2913
            SVGPoint point;
 
2914
            return point;
 
2915
            }
 
2916
        std::vector<SVGPoint>::iterator iter = items.begin() + index;
 
2917
        *iter = newItem;
 
2918
        return newItem;
 
2919
        }
 
2920
 
 
2921
    /**
 
2922
     *
 
2923
     */
 
2924
    virtual SVGPoint removeItem(unsigned long index )
 
2925
                                  throw( DOMException )
 
2926
        {
 
2927
        if (index >= items.size())
 
2928
            {
 
2929
            SVGPoint point;
 
2930
            return point;
 
2931
            }
 
2932
        std::vector<SVGPoint>::iterator iter = items.begin() + index;
 
2933
        SVGPoint oldItem = *iter;
 
2934
        items.erase(iter);
 
2935
        return oldItem;
 
2936
        }
 
2937
 
 
2938
    /**
 
2939
     *
 
2940
     */
 
2941
    virtual SVGPoint appendItem(const SVGPoint &newItem)
 
2942
                              throw( DOMException, SVGException )
 
2943
        {
 
2944
        items.push_back(newItem);
 
2945
        return newItem;
 
2946
        }
 
2947
 
 
2948
 
 
2949
    //##################
 
2950
    //# Non-API methods
 
2951
    //##################
 
2952
 
 
2953
    /**
 
2954
     *
 
2955
     */
 
2956
    SVGPointList() {}
 
2957
 
 
2958
 
 
2959
    /**
 
2960
     *
 
2961
     */
 
2962
    SVGPointList(const SVGPointList &other)
 
2963
        {
 
2964
        items = other.items;
 
2965
        }
 
2966
 
 
2967
 
 
2968
    /**
 
2969
     *
 
2970
     */
 
2971
    virtual ~SVGPointList() {}
 
2972
 
 
2973
protected:
 
2974
 
 
2975
    std::vector<SVGPoint> items;
 
2976
 
 
2977
};
 
2978
 
 
2979
 
 
2980
 
 
2981
 
 
2982
/*#########################################################################
 
2983
## SVGUnitTypes
 
2984
#########################################################################*/
 
2985
 
 
2986
/**
 
2987
 *
 
2988
 */
 
2989
class SVGUnitTypes
 
2990
{
 
2991
public:
 
2992
 
 
2993
    /**
 
2994
     * Unit Types
 
2995
     */
 
2996
    typedef enum
 
2997
        {
 
2998
        SVG_UNIT_TYPE_UNKNOWN           = 0,
 
2999
        SVG_UNIT_TYPE_USERSPACEONUSE    = 1,
 
3000
        SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2
 
3001
        } UnitType;
 
3002
 
 
3003
 
 
3004
 
 
3005
    //##################
 
3006
    //# Non-API methods
 
3007
    //##################
 
3008
 
 
3009
    /**
 
3010
     *
 
3011
     */
 
3012
    SVGUnitTypes() {}
 
3013
 
 
3014
    /**
 
3015
     *
 
3016
     */
 
3017
    virtual ~SVGUnitTypes() {}
 
3018
 
 
3019
};
 
3020
 
 
3021
 
 
3022
 
 
3023
 
 
3024
 
 
3025
 
 
3026
/*#########################################################################
 
3027
## SVGStylable
 
3028
#########################################################################*/
 
3029
 
 
3030
/**
 
3031
 *
 
3032
 */
 
3033
class SVGStylable
 
3034
{
 
3035
public:
 
3036
 
 
3037
    /**
 
3038
     *
 
3039
     */
 
3040
    virtual SVGAnimatedString getClassName()
 
3041
        {
 
3042
        return className;
 
3043
        }
 
3044
 
 
3045
    /**
 
3046
     *
 
3047
     */
 
3048
    virtual css::CSSStyleDeclaration getStyle()
 
3049
        {
 
3050
        return style;
 
3051
        }
 
3052
 
 
3053
 
 
3054
    /**
 
3055
     *
 
3056
     */
 
3057
    virtual css::CSSValue getPresentationAttribute (const DOMString& /*name*/ )
 
3058
        {
 
3059
        css::CSSValue val;
 
3060
        //perform a lookup
 
3061
        return val;
 
3062
        }
 
3063
 
 
3064
 
 
3065
    //##################
 
3066
    //# Non-API methods
 
3067
    //##################
 
3068
 
 
3069
    /**
 
3070
     *
 
3071
     */
 
3072
    SVGStylable() {}
 
3073
 
 
3074
    /**
 
3075
     *
 
3076
     */
 
3077
    SVGStylable(const SVGStylable &other)
 
3078
        {
 
3079
        className = other.className;
 
3080
        style     = other.style;
 
3081
        }
 
3082
 
 
3083
    /**
 
3084
     *
 
3085
     */
 
3086
    virtual ~SVGStylable() {}
 
3087
 
 
3088
protected:
 
3089
 
 
3090
    SVGAnimatedString className;
 
3091
    css::CSSStyleDeclaration style;
 
3092
 
 
3093
};
 
3094
 
 
3095
 
 
3096
/*#########################################################################
 
3097
## SVGLocatable
 
3098
#########################################################################*/
 
3099
 
 
3100
/**
 
3101
 *
 
3102
 */
 
3103
class SVGLocatable
 
3104
{
 
3105
public:
 
3106
 
 
3107
    /**
 
3108
     *
 
3109
     */
 
3110
    virtual SVGElementPtr getNearestViewportElement()
 
3111
        {
 
3112
        SVGElementPtr result;
 
3113
        return result;
 
3114
        }
 
3115
 
 
3116
    /**
 
3117
     *
 
3118
     */
 
3119
    virtual SVGElementPtr getFarthestViewportElement()
 
3120
        {
 
3121
        SVGElementPtr result;
 
3122
        return result;
 
3123
        }
 
3124
 
 
3125
    /**
 
3126
     *
 
3127
     */
 
3128
    virtual SVGRect getBBox (  )
 
3129
        {
 
3130
        return bbox;
 
3131
        }
 
3132
 
 
3133
    /**
 
3134
     *
 
3135
     */
 
3136
    virtual SVGMatrix getCTM (  )
 
3137
        {
 
3138
        return ctm;
 
3139
        }
 
3140
 
 
3141
    /**
 
3142
     *
 
3143
     */
 
3144
    virtual SVGMatrix getScreenCTM (  )
 
3145
        {
 
3146
        return screenCtm;
 
3147
        }
 
3148
 
 
3149
    /**
 
3150
     *
 
3151
     */
 
3152
    virtual SVGMatrix getTransformToElement (const SVGElement &/*element*/)
 
3153
                    throw( SVGException )
 
3154
        {
 
3155
        SVGMatrix result;
 
3156
        //do calculations
 
3157
        return result;
 
3158
        }
 
3159
 
 
3160
 
 
3161
 
 
3162
    //##################
 
3163
    //# Non-API methods
 
3164
    //##################
 
3165
 
 
3166
    /**
 
3167
     *
 
3168
     */
 
3169
    SVGLocatable() {}
 
3170
 
 
3171
    /**
 
3172
     *
 
3173
     */
 
3174
    SVGLocatable(const SVGLocatable &/*other*/)
 
3175
        {
 
3176
        }
 
3177
 
 
3178
    /**
 
3179
     *
 
3180
     */
 
3181
    virtual ~SVGLocatable() {}
 
3182
 
 
3183
protected:
 
3184
 
 
3185
    SVGRect bbox;
 
3186
    SVGMatrix ctm;
 
3187
    SVGMatrix screenCtm;
 
3188
 
 
3189
};
 
3190
 
 
3191
 
 
3192
 
 
3193
 
 
3194
 
 
3195
 
 
3196
/*#########################################################################
 
3197
## SVGTransformable
 
3198
#########################################################################*/
 
3199
 
 
3200
/**
 
3201
 *
 
3202
 */
 
3203
class SVGTransformable : public SVGLocatable
 
3204
{
 
3205
public:
 
3206
 
 
3207
 
 
3208
    /**
 
3209
     *
 
3210
     */
 
3211
    virtual SVGAnimatedTransformList &getTransform()
 
3212
        {
 
3213
        return transforms;
 
3214
        }
 
3215
 
 
3216
 
 
3217
 
 
3218
    //##################
 
3219
    //# Non-API methods
 
3220
    //##################
 
3221
 
 
3222
    /**
 
3223
     *
 
3224
     */
 
3225
    SVGTransformable() {}
 
3226
 
 
3227
    /**
 
3228
     *
 
3229
     */
 
3230
    SVGTransformable(const SVGTransformable &other) : SVGLocatable(other)
 
3231
        {
 
3232
        transforms = other.transforms;
 
3233
        }
 
3234
 
 
3235
    /**
 
3236
     *
 
3237
     */
 
3238
    virtual ~SVGTransformable() {}
 
3239
 
 
3240
protected:
 
3241
 
 
3242
    SVGAnimatedTransformList transforms;
 
3243
};
 
3244
 
 
3245
 
 
3246
 
 
3247
 
 
3248
 
 
3249
 
 
3250
/*#########################################################################
 
3251
## SVGTests
 
3252
#########################################################################*/
 
3253
 
 
3254
/**
 
3255
 *
 
3256
 */
 
3257
class SVGTests
 
3258
{
 
3259
public:
 
3260
 
 
3261
 
 
3262
    /**
 
3263
     *
 
3264
     */
 
3265
    virtual SVGStringList &getRequiredFeatures()
 
3266
        {
 
3267
        return requiredFeatures;
 
3268
        }
 
3269
 
 
3270
    /**
 
3271
     *
 
3272
     */
 
3273
    virtual SVGStringList &getRequiredExtensions()
 
3274
        {
 
3275
        return requiredExtensions;
 
3276
        }
 
3277
 
 
3278
    /**
 
3279
     *
 
3280
     */
 
3281
    virtual SVGStringList &getSystemLanguage()
 
3282
        {
 
3283
        return systemLanguage;
 
3284
        }
 
3285
 
 
3286
 
 
3287
    /**
 
3288
     *
 
3289
     */
 
3290
    virtual bool hasExtension (const DOMString& /*extension*/ )
 
3291
        {
 
3292
        return false;
 
3293
        }
 
3294
 
 
3295
 
 
3296
 
 
3297
    //##################
 
3298
    //# Non-API methods
 
3299
    //##################
 
3300
 
 
3301
    /**
 
3302
     *
 
3303
     */
 
3304
    SVGTests() {}
 
3305
 
 
3306
    /**
 
3307
     *
 
3308
     */
 
3309
    SVGTests(const SVGTests &other)
 
3310
        {
 
3311
        requiredFeatures   = other.requiredFeatures;
 
3312
        requiredExtensions = other.requiredExtensions;
 
3313
        systemLanguage     = other.systemLanguage;
 
3314
        }
 
3315
 
 
3316
    /**
 
3317
     *
 
3318
     */
 
3319
    virtual ~SVGTests() {}
 
3320
 
 
3321
protected:
 
3322
 
 
3323
    SVGStringList requiredFeatures;
 
3324
    SVGStringList requiredExtensions;
 
3325
    SVGStringList systemLanguage;
 
3326
 
 
3327
};
 
3328
 
 
3329
 
 
3330
 
 
3331
 
 
3332
 
 
3333
 
 
3334
/*#########################################################################
 
3335
## SVGLangSpace
 
3336
#########################################################################*/
 
3337
 
 
3338
/**
 
3339
 *
 
3340
 */
 
3341
class SVGLangSpace
 
3342
{
 
3343
public:
 
3344
 
 
3345
 
 
3346
    /**
 
3347
     *
 
3348
     */
 
3349
    virtual DOMString getXmllang()
 
3350
        {
 
3351
        return xmlLang;
 
3352
        }
 
3353
 
 
3354
    /**
 
3355
     *
 
3356
     */
 
3357
    virtual void setXmllang(const DOMString &val)
 
3358
                                     throw (DOMException)
 
3359
        {
 
3360
        xmlLang = val;
 
3361
        }
 
3362
 
 
3363
    /**
 
3364
     *
 
3365
     */
 
3366
    virtual DOMString getXmlspace()
 
3367
        {
 
3368
        return xmlSpace;
 
3369
        }
 
3370
 
 
3371
    /**
 
3372
     *
 
3373
     */
 
3374
    virtual void setXmlspace(const DOMString &val)
 
3375
                                     throw (DOMException)
 
3376
        {
 
3377
        xmlSpace = val;
 
3378
        }
 
3379
 
 
3380
 
 
3381
 
 
3382
    //##################
 
3383
    //# Non-API methods
 
3384
    //##################
 
3385
 
 
3386
    /**
 
3387
     *
 
3388
     */
 
3389
    SVGLangSpace() {}
 
3390
 
 
3391
    /**
 
3392
     *
 
3393
     */
 
3394
    SVGLangSpace(const SVGLangSpace &other)
 
3395
        {
 
3396
        xmlLang  = other.xmlLang;
 
3397
        xmlSpace = other.xmlSpace;
 
3398
        }
 
3399
 
 
3400
    /**
 
3401
     *
 
3402
     */
 
3403
    virtual ~SVGLangSpace() {}
 
3404
 
 
3405
protected:
 
3406
 
 
3407
    DOMString xmlLang;
 
3408
    DOMString xmlSpace;
 
3409
 
 
3410
};
 
3411
 
 
3412
 
 
3413
 
 
3414
 
 
3415
 
 
3416
 
 
3417
/*#########################################################################
 
3418
## SVGExternalResourcesRequired
 
3419
#########################################################################*/
 
3420
 
 
3421
/**
 
3422
 *
 
3423
 */
 
3424
class SVGExternalResourcesRequired
 
3425
{
 
3426
public:
 
3427
 
 
3428
 
 
3429
    /**
 
3430
     *
 
3431
     */
 
3432
    virtual SVGAnimatedBoolean getExternalResourcesRequired()
 
3433
        { return required; }
 
3434
 
 
3435
 
 
3436
 
 
3437
    //##################
 
3438
    //# Non-API methods
 
3439
    //##################
 
3440
 
 
3441
    /**
 
3442
     *
 
3443
     */
 
3444
    SVGExternalResourcesRequired()
 
3445
        {  }
 
3446
 
 
3447
 
 
3448
    /**
 
3449
     *
 
3450
     */
 
3451
    SVGExternalResourcesRequired(const SVGExternalResourcesRequired &other)
 
3452
        {
 
3453
        required = other.required;
 
3454
        }
 
3455
 
 
3456
    /**
 
3457
     *
 
3458
     */
 
3459
    virtual ~SVGExternalResourcesRequired() {}
 
3460
 
 
3461
protected:
 
3462
 
 
3463
    SVGAnimatedBoolean required;
 
3464
 
 
3465
};
 
3466
 
 
3467
 
 
3468
 
 
3469
 
 
3470
 
 
3471
 
 
3472
/*#########################################################################
 
3473
## SVGPreserveAspectRatio
 
3474
#########################################################################*/
 
3475
 
 
3476
/**
 
3477
 *
 
3478
 */
 
3479
class SVGPreserveAspectRatio
 
3480
{
 
3481
public:
 
3482
 
 
3483
 
 
3484
    /**
 
3485
     * Alignment Types
 
3486
     */
 
3487
    typedef enum
 
3488
        {
 
3489
        SVG_PRESERVEASPECTRATIO_UNKNOWN  = 0,
 
3490
        SVG_PRESERVEASPECTRATIO_NONE     = 1,
 
3491
        SVG_PRESERVEASPECTRATIO_XMINYMIN = 2,
 
3492
        SVG_PRESERVEASPECTRATIO_XMIDYMIN = 3,
 
3493
        SVG_PRESERVEASPECTRATIO_XMAXYMIN = 4,
 
3494
        SVG_PRESERVEASPECTRATIO_XMINYMID = 5,
 
3495
        SVG_PRESERVEASPECTRATIO_XMIDYMID = 6,
 
3496
        SVG_PRESERVEASPECTRATIO_XMAXYMID = 7,
 
3497
        SVG_PRESERVEASPECTRATIO_XMINYMAX = 8,
 
3498
        SVG_PRESERVEASPECTRATIO_XMIDYMAX = 9,
 
3499
        SVG_PRESERVEASPECTRATIO_XMAXYMAX = 10
 
3500
        } AlignmentType;
 
3501
 
 
3502
 
 
3503
    /**
 
3504
     * Meet-or-slice Types
 
3505
     */
 
3506
    typedef enum
 
3507
        {
 
3508
        SVG_MEETORSLICE_UNKNOWN  = 0,
 
3509
        SVG_MEETORSLICE_MEET     = 1,
 
3510
        SVG_MEETORSLICE_SLICE    = 2
 
3511
        } MeetOrSliceType;
 
3512
 
 
3513
 
 
3514
    /**
 
3515
     *
 
3516
     */
 
3517
    virtual unsigned short getAlign()
 
3518
        { return align; }
 
3519
 
 
3520
    /**
 
3521
     *
 
3522
     */
 
3523
    virtual void setAlign(unsigned short val) throw (DOMException)
 
3524
        { align = val; }
 
3525
 
 
3526
    /**
 
3527
     *
 
3528
     */
 
3529
    virtual unsigned short getMeetOrSlice()
 
3530
        { return meetOrSlice; }
 
3531
 
 
3532
    /**
 
3533
     *
 
3534
     */
 
3535
    virtual void setMeetOrSlice(unsigned short val) throw (DOMException)
 
3536
        { meetOrSlice = val; }
 
3537
 
 
3538
 
 
3539
 
 
3540
    //##################
 
3541
    //# Non-API methods
 
3542
    //##################
 
3543
 
 
3544
    /**
 
3545
     *
 
3546
     */
 
3547
    SVGPreserveAspectRatio()
 
3548
        {
 
3549
        align       = SVG_PRESERVEASPECTRATIO_UNKNOWN;
 
3550
        meetOrSlice = SVG_MEETORSLICE_UNKNOWN;
 
3551
        }
 
3552
 
 
3553
    /**
 
3554
     *
 
3555
     */
 
3556
    SVGPreserveAspectRatio(const SVGPreserveAspectRatio &other)
 
3557
        {
 
3558
        align       = other.align;
 
3559
        meetOrSlice = other.meetOrSlice;
 
3560
        }
 
3561
 
 
3562
    /**
 
3563
     *
 
3564
     */
 
3565
    virtual ~SVGPreserveAspectRatio() {}
 
3566
 
 
3567
protected:
 
3568
 
 
3569
    unsigned short align;
 
3570
    unsigned short meetOrSlice;
 
3571
 
 
3572
};
 
3573
 
 
3574
 
 
3575
 
 
3576
 
 
3577
 
 
3578
 
 
3579
/*#########################################################################
 
3580
## SVGAnimatedPreserveAspectRatio
 
3581
#########################################################################*/
 
3582
 
 
3583
/**
 
3584
 *
 
3585
 */
 
3586
class SVGAnimatedPreserveAspectRatio
 
3587
{
 
3588
public:
 
3589
 
 
3590
 
 
3591
    /**
 
3592
     *
 
3593
     */
 
3594
    virtual SVGPreserveAspectRatio getBaseVal()
 
3595
        { return baseVal; }
 
3596
 
 
3597
    /**
 
3598
     *
 
3599
     */
 
3600
    virtual SVGPreserveAspectRatio getAnimVal()
 
3601
        { return animVal; }
 
3602
 
 
3603
 
 
3604
 
 
3605
    //##################
 
3606
    //# Non-API methods
 
3607
    //##################
 
3608
 
 
3609
    /**
 
3610
     *
 
3611
     */
 
3612
    SVGAnimatedPreserveAspectRatio() {}
 
3613
 
 
3614
    /**
 
3615
     *
 
3616
     */
 
3617
    SVGAnimatedPreserveAspectRatio(const SVGAnimatedPreserveAspectRatio &other)
 
3618
        {
 
3619
        baseVal = other.baseVal;
 
3620
        baseVal = other.animVal;
 
3621
        }
 
3622
 
 
3623
    /**
 
3624
     *
 
3625
     */
 
3626
    virtual ~SVGAnimatedPreserveAspectRatio() {}
 
3627
 
 
3628
protected:
 
3629
 
 
3630
    SVGPreserveAspectRatio baseVal;
 
3631
    SVGPreserveAspectRatio animVal;
 
3632
 
 
3633
};
 
3634
 
 
3635
 
 
3636
 
 
3637
 
 
3638
/*#########################################################################
 
3639
## SVGFitToViewBox
 
3640
#########################################################################*/
 
3641
 
 
3642
/**
 
3643
 *
 
3644
 */
 
3645
class SVGFitToViewBox
 
3646
{
 
3647
public:
 
3648
 
 
3649
    /**
 
3650
     *
 
3651
     */
 
3652
    virtual SVGAnimatedRect getViewBox()
 
3653
        { return viewBox; }
 
3654
 
 
3655
    /**
 
3656
     *
 
3657
     */
 
3658
    virtual SVGAnimatedPreserveAspectRatio getPreserveAspectRatio()
 
3659
        { return preserveAspectRatio; }
 
3660
 
 
3661
 
 
3662
 
 
3663
    //##################
 
3664
    //# Non-API methods
 
3665
    //##################
 
3666
 
 
3667
    /**
 
3668
     *
 
3669
     */
 
3670
    SVGFitToViewBox()
 
3671
        {}
 
3672
 
 
3673
    /**
 
3674
     *
 
3675
     */
 
3676
 
 
3677
    SVGFitToViewBox(const SVGFitToViewBox &other)
 
3678
        {
 
3679
        viewBox = other.viewBox;
 
3680
        preserveAspectRatio = other.preserveAspectRatio;
 
3681
        }
 
3682
 
 
3683
    /**
 
3684
     *
 
3685
     */
 
3686
    virtual ~SVGFitToViewBox() {}
 
3687
 
 
3688
protected:
 
3689
 
 
3690
    SVGAnimatedRect viewBox;
 
3691
 
 
3692
    SVGAnimatedPreserveAspectRatio preserveAspectRatio;
 
3693
 
 
3694
};
 
3695
 
 
3696
 
 
3697
/*#########################################################################
 
3698
## SVGZoomAndPan
 
3699
#########################################################################*/
 
3700
 
 
3701
/**
 
3702
 *
 
3703
 */
 
3704
class SVGZoomAndPan
 
3705
{
 
3706
public:
 
3707
 
 
3708
 
 
3709
    /**
 
3710
     * Zoom and Pan Types
 
3711
     */
 
3712
    typedef enum
 
3713
        {
 
3714
        SVG_ZOOMANDPAN_UNKNOWN = 0,
 
3715
        SVG_ZOOMANDPAN_DISABLE = 1,
 
3716
        SVG_ZOOMANDPAN_MAGNIFY = 2
 
3717
        } ZoomAndPanType;
 
3718
 
 
3719
 
 
3720
    /**
 
3721
     *
 
3722
     */
 
3723
    virtual unsigned short getZoomAndPan()
 
3724
        { return zoomAndPan; }
 
3725
 
 
3726
    /**
 
3727
     *
 
3728
     */
 
3729
    virtual void setZoomAndPan(unsigned short val) throw (DOMException)
 
3730
        { zoomAndPan = val; }
 
3731
 
 
3732
 
 
3733
    //##################
 
3734
    //# Non-API methods
 
3735
    //##################
 
3736
 
 
3737
    /**
 
3738
     *
 
3739
     */
 
3740
    SVGZoomAndPan()
 
3741
        { zoomAndPan = SVG_ZOOMANDPAN_UNKNOWN; }
 
3742
 
 
3743
    /**
 
3744
     *
 
3745
     */
 
3746
    SVGZoomAndPan(const SVGZoomAndPan &other)
 
3747
        { zoomAndPan = other.zoomAndPan; }
 
3748
 
 
3749
    /**
 
3750
     *
 
3751
     */
 
3752
    virtual ~SVGZoomAndPan() {}
 
3753
 
 
3754
protected:
 
3755
 
 
3756
    unsigned short zoomAndPan;
 
3757
 
 
3758
};
 
3759
 
 
3760
 
 
3761
 
 
3762
 
 
3763
 
 
3764
 
 
3765
/*#########################################################################
 
3766
## SVGViewSpec
 
3767
#########################################################################*/
 
3768
 
 
3769
/**
 
3770
 *
 
3771
 */
 
3772
class SVGViewSpec : public SVGZoomAndPan,
 
3773
                    public SVGFitToViewBox
 
3774
{
 
3775
public:
 
3776
 
 
3777
    /**
 
3778
     *
 
3779
     */
 
3780
    virtual SVGTransformList getTransform()
 
3781
        { return transform; }
 
3782
 
 
3783
    /**
 
3784
     *
 
3785
     */
 
3786
    virtual SVGElementPtr getViewTarget()
 
3787
        { return viewTarget; }
 
3788
 
 
3789
    /**
 
3790
     *
 
3791
     */
 
3792
    virtual DOMString getViewBoxString()
 
3793
        {
 
3794
        DOMString ret;
 
3795
        return ret;
 
3796
        }
 
3797
 
 
3798
    /**
 
3799
     *
 
3800
     */
 
3801
    virtual DOMString getPreserveAspectRatioString()
 
3802
        {
 
3803
        DOMString ret;
 
3804
        return ret;
 
3805
        }
 
3806
 
 
3807
    /**
 
3808
     *
 
3809
     */
 
3810
    virtual DOMString getTransformString()
 
3811
        {
 
3812
        DOMString ret;
 
3813
        return ret;
 
3814
        }
 
3815
 
 
3816
    /**
 
3817
     *
 
3818
     */
 
3819
    virtual DOMString getViewTargetString()
 
3820
        {
 
3821
        DOMString ret;
 
3822
        return ret;
 
3823
        }
 
3824
 
 
3825
 
 
3826
 
 
3827
    //##################
 
3828
    //# Non-API methods
 
3829
    //##################
 
3830
 
 
3831
    /**
 
3832
     *
 
3833
     */
 
3834
    SVGViewSpec()
 
3835
        {
 
3836
        viewTarget = NULL;
 
3837
        }
 
3838
 
 
3839
    /**
 
3840
     *
 
3841
     */
 
3842
    SVGViewSpec(const SVGViewSpec &other) : SVGZoomAndPan(other), SVGFitToViewBox(other)
 
3843
        {
 
3844
        viewTarget = other.viewTarget;
 
3845
        transform  = other.transform;
 
3846
        }
 
3847
 
 
3848
    /**
 
3849
     *
 
3850
     */
 
3851
    virtual ~SVGViewSpec() {}
 
3852
 
 
3853
protected:
 
3854
 
 
3855
    SVGElementPtr viewTarget;
 
3856
    SVGTransformList transform;
 
3857
};
 
3858
 
 
3859
 
 
3860
 
 
3861
 
 
3862
 
 
3863
 
 
3864
/*#########################################################################
 
3865
## SVGURIReference
 
3866
#########################################################################*/
 
3867
 
 
3868
/**
 
3869
 *
 
3870
 */
 
3871
class SVGURIReference
 
3872
{
 
3873
public:
 
3874
 
 
3875
    /**
 
3876
     *
 
3877
     */
 
3878
    virtual SVGAnimatedString getHref()
 
3879
        { return href; }
 
3880
 
 
3881
 
 
3882
 
 
3883
    //##################
 
3884
    //# Non-API methods
 
3885
    //##################
 
3886
 
 
3887
    /**
 
3888
     *
 
3889
     */
 
3890
    SVGURIReference() {}
 
3891
 
 
3892
    /**
 
3893
     *
 
3894
     */
 
3895
    SVGURIReference(const SVGURIReference &other)
 
3896
        {
 
3897
        href = other.href;
 
3898
        }
 
3899
 
 
3900
    /**
 
3901
     *
 
3902
     */
 
3903
    virtual ~SVGURIReference() {}
 
3904
 
 
3905
protected:
 
3906
 
 
3907
    SVGAnimatedString href;
 
3908
 
 
3909
};
 
3910
 
 
3911
 
 
3912
 
 
3913
 
 
3914
 
 
3915
 
 
3916
/*#########################################################################
 
3917
## SVGCSSRule
 
3918
#########################################################################*/
 
3919
 
 
3920
/**
 
3921
 *
 
3922
 */
 
3923
class SVGCSSRule : public css::CSSRule
 
3924
{
 
3925
public:
 
3926
 
 
3927
 
 
3928
    /**
 
3929
     * Additional CSS RuleType to support ICC color specifications
 
3930
     */
 
3931
    typedef enum
 
3932
        {
 
3933
        COLOR_PROFILE_RULE = 7
 
3934
        } ColorProfileRuleType;
 
3935
 
 
3936
    //##################
 
3937
    //# Non-API methods
 
3938
    //##################
 
3939
 
 
3940
    /**
 
3941
     *
 
3942
     */
 
3943
    SVGCSSRule()
 
3944
        { type = COLOR_PROFILE_RULE; }
 
3945
 
 
3946
    /**
 
3947
     *
 
3948
     */
 
3949
    SVGCSSRule(const SVGCSSRule &other) : css::CSSRule(other)
 
3950
        { type = COLOR_PROFILE_RULE; }
 
3951
 
 
3952
    /**
 
3953
     *
 
3954
     */
 
3955
    virtual ~SVGCSSRule() {}
 
3956
 
 
3957
};
 
3958
 
 
3959
 
 
3960
 
 
3961
/*#########################################################################
 
3962
## SVGRenderingIntent
 
3963
#########################################################################*/
 
3964
 
 
3965
/**
 
3966
 *
 
3967
 */
 
3968
class SVGRenderingIntent
 
3969
{
 
3970
public:
 
3971
 
 
3972
    /**
 
3973
     * Rendering Intent Types
 
3974
     */
 
3975
    typedef enum
 
3976
        {
 
3977
        RENDERING_INTENT_UNKNOWN               = 0,
 
3978
        RENDERING_INTENT_AUTO                  = 1,
 
3979
        RENDERING_INTENT_PERCEPTUAL            = 2,
 
3980
        RENDERING_INTENT_RELATIVE_COLORIMETRIC = 3,
 
3981
        RENDERING_INTENT_SATURATION            = 4,
 
3982
        RENDERING_INTENT_ABSOLUTE_COLORIMETRIC = 5
 
3983
        } RenderingIntentType;
 
3984
 
 
3985
 
 
3986
 
 
3987
    //##################
 
3988
    //# Non-API methods
 
3989
    //##################
 
3990
 
 
3991
    /**
 
3992
     *
 
3993
     */
 
3994
    SVGRenderingIntent()
 
3995
        {
 
3996
        renderingIntentType = RENDERING_INTENT_UNKNOWN;
 
3997
        }
 
3998
 
 
3999
    /**
 
4000
     *
 
4001
     */
 
4002
    SVGRenderingIntent(const SVGRenderingIntent &other)
 
4003
        {
 
4004
        renderingIntentType = other.renderingIntentType;
 
4005
        }
 
4006
 
 
4007
    /**
 
4008
     *
 
4009
     */
 
4010
    virtual ~SVGRenderingIntent() {}
 
4011
 
 
4012
protected:
 
4013
 
 
4014
    unsigned short renderingIntentType;
 
4015
};
 
4016
 
 
4017
 
 
4018
 
 
4019
 
 
4020
 
 
4021
 
 
4022
 
 
4023
/*#########################################################################
 
4024
###########################################################################
 
4025
## P A T H    S E G M E N T S
 
4026
###########################################################################
 
4027
#########################################################################*/
 
4028
 
 
4029
static char const *const pathSegLetters[] =
 
4030
{
 
4031
    "@", // PATHSEG_UNKNOWN,
 
4032
    "z", // PATHSEG_CLOSEPATH
 
4033
    "M", // PATHSEG_MOVETO_ABS
 
4034
    "m", // PATHSEG_MOVETO_REL,
 
4035
    "L", // PATHSEG_LINETO_ABS
 
4036
    "l", // PATHSEG_LINETO_REL
 
4037
    "C", // PATHSEG_CURVETO_CUBIC_ABS
 
4038
    "c", // PATHSEG_CURVETO_CUBIC_REL
 
4039
    "Q", // PATHSEG_CURVETO_QUADRATIC_ABS,
 
4040
    "q", // PATHSEG_CURVETO_QUADRATIC_REL
 
4041
    "A", // PATHSEG_ARC_ABS
 
4042
    "a", // PATHSEG_ARC_REL,
 
4043
    "H", // PATHSEG_LINETO_HORIZONTAL_ABS,
 
4044
    "h", // PATHSEG_LINETO_HORIZONTAL_REL
 
4045
    "V", // PATHSEG_LINETO_VERTICAL_ABS
 
4046
    "v", // PATHSEG_LINETO_VERTICAL_REL
 
4047
    "S", // PATHSEG_CURVETO_CUBIC_SMOOTH_ABS
 
4048
    "s", // PATHSEG_CURVETO_CUBIC_SMOOTH_REL
 
4049
    "T", // PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS
 
4050
    "t"  // PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL
 
4051
};
 
4052
 
 
4053
/*#########################################################################
 
4054
## SVGPathSeg
 
4055
#########################################################################*/
 
4056
 
 
4057
/**
 
4058
 *
 
4059
 */
 
4060
class SVGPathSeg
 
4061
{
 
4062
public:
 
4063
 
 
4064
 
 
4065
 
 
4066
    /**
 
4067
     *  Path Segment Types
 
4068
     */
 
4069
    typedef enum
 
4070
        {
 
4071
        PATHSEG_UNKNOWN                      = 0,
 
4072
        PATHSEG_CLOSEPATH                    = 1,
 
4073
        PATHSEG_MOVETO_ABS                   = 2,
 
4074
        PATHSEG_MOVETO_REL                   = 3,
 
4075
        PATHSEG_LINETO_ABS                   = 4,
 
4076
        PATHSEG_LINETO_REL                   = 5,
 
4077
        PATHSEG_CURVETO_CUBIC_ABS            = 6,
 
4078
        PATHSEG_CURVETO_CUBIC_REL            = 7,
 
4079
        PATHSEG_CURVETO_QUADRATIC_ABS        = 8,
 
4080
        PATHSEG_CURVETO_QUADRATIC_REL        = 9,
 
4081
        PATHSEG_ARC_ABS                      = 10,
 
4082
        PATHSEG_ARC_REL                      = 11,
 
4083
        PATHSEG_LINETO_HORIZONTAL_ABS        = 12,
 
4084
        PATHSEG_LINETO_HORIZONTAL_REL        = 13,
 
4085
        PATHSEG_LINETO_VERTICAL_ABS          = 14,
 
4086
        PATHSEG_LINETO_VERTICAL_REL          = 15,
 
4087
        PATHSEG_CURVETO_CUBIC_SMOOTH_ABS     = 16,
 
4088
        PATHSEG_CURVETO_CUBIC_SMOOTH_REL     = 17,
 
4089
        PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18,
 
4090
        PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19
 
4091
        } PathSegmentType;
 
4092
 
 
4093
    /**
 
4094
     *
 
4095
     */
 
4096
    virtual unsigned short getPathSegType()
 
4097
        { return type; }
 
4098
 
 
4099
    /**
 
4100
     *
 
4101
     */
 
4102
    virtual DOMString getPathSegTypeAsLetter()
 
4103
        {
 
4104
        int typ = type;
 
4105
        if (typ<0 || typ>PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL)
 
4106
            typ = PATHSEG_UNKNOWN;
 
4107
        char const *ch = pathSegLetters[typ];
 
4108
        DOMString letter = ch;
 
4109
        return letter;
 
4110
        }
 
4111
 
 
4112
 
 
4113
 
 
4114
    //##################
 
4115
    //# Non-API methods
 
4116
    //##################
 
4117
 
 
4118
    /**
 
4119
     *
 
4120
     */
 
4121
    SVGPathSeg()
 
4122
        { type = PATHSEG_UNKNOWN; }
 
4123
 
 
4124
    /**
 
4125
     *
 
4126
     */
 
4127
    SVGPathSeg(const SVGPathSeg &other)
 
4128
        {
 
4129
        type = other.type;
 
4130
        }
 
4131
 
 
4132
    /**
 
4133
     *
 
4134
     */
 
4135
    virtual ~SVGPathSeg() {}
 
4136
 
 
4137
protected:
 
4138
 
 
4139
    int type;
 
4140
 
 
4141
};
 
4142
 
 
4143
 
 
4144
 
 
4145
 
 
4146
 
 
4147
 
 
4148
/*#########################################################################
 
4149
## SVGPathSegClosePath
 
4150
#########################################################################*/
 
4151
 
 
4152
/**
 
4153
 *
 
4154
 */
 
4155
class SVGPathSegClosePath : public SVGPathSeg
 
4156
{
 
4157
public:
 
4158
 
 
4159
    //##################
 
4160
    //# Non-API methods
 
4161
    //##################
 
4162
 
 
4163
    /**
 
4164
     *
 
4165
     */
 
4166
    SVGPathSegClosePath()
 
4167
        {
 
4168
        type = PATHSEG_CLOSEPATH;
 
4169
        }
 
4170
 
 
4171
    /**
 
4172
     *
 
4173
     */
 
4174
    SVGPathSegClosePath(const SVGPathSegClosePath &other) : SVGPathSeg(other)
 
4175
        {
 
4176
        type = PATHSEG_CLOSEPATH;
 
4177
        }
 
4178
 
 
4179
    /**
 
4180
     *
 
4181
     */
 
4182
    virtual ~SVGPathSegClosePath() {}
 
4183
 
 
4184
};
 
4185
 
 
4186
 
 
4187
 
 
4188
 
 
4189
/*#########################################################################
 
4190
## SVGPathSegMovetoAbs
 
4191
#########################################################################*/
 
4192
 
 
4193
/**
 
4194
 *
 
4195
 */
 
4196
class SVGPathSegMovetoAbs : public SVGPathSeg
 
4197
{
 
4198
public:
 
4199
 
 
4200
    /**
 
4201
     *
 
4202
     */
 
4203
    virtual double getX()
 
4204
        { return x; }
 
4205
 
 
4206
    /**
 
4207
     *
 
4208
     */
 
4209
    virtual void setX(double val) throw (DOMException)
 
4210
        { x = val; }
 
4211
 
 
4212
    /**
 
4213
     *
 
4214
     */
 
4215
    virtual double getY()
 
4216
        { return y; }
 
4217
 
 
4218
    /**
 
4219
     *
 
4220
     */
 
4221
    virtual void setY(double val) throw (DOMException)
 
4222
        { y = val; }
 
4223
 
 
4224
    //##################
 
4225
    //# Non-API methods
 
4226
    //##################
 
4227
 
 
4228
    /**
 
4229
     *
 
4230
     */
 
4231
    SVGPathSegMovetoAbs()
 
4232
        {
 
4233
        type = PATHSEG_MOVETO_ABS;
 
4234
        x = y = 0.0;
 
4235
        }
 
4236
 
 
4237
    /**
 
4238
     *
 
4239
     */
 
4240
    SVGPathSegMovetoAbs(double xArg, double yArg)
 
4241
        {
 
4242
        type = PATHSEG_MOVETO_ABS;
 
4243
        x = xArg; y = yArg;
 
4244
        }
 
4245
 
 
4246
    /**
 
4247
     *
 
4248
     */
 
4249
    SVGPathSegMovetoAbs(const SVGPathSegMovetoAbs &other) : SVGPathSeg(other)
 
4250
        {
 
4251
        type = PATHSEG_MOVETO_ABS;
 
4252
        x = other.x; y = other.y;
 
4253
        }
 
4254
 
 
4255
    /**
 
4256
     *
 
4257
     */
 
4258
    virtual ~SVGPathSegMovetoAbs() {}
 
4259
 
 
4260
protected:
 
4261
 
 
4262
    double x,y;
 
4263
 
 
4264
};
 
4265
 
 
4266
 
 
4267
 
 
4268
 
 
4269
 
 
4270
 
 
4271
/*#########################################################################
 
4272
## SVGPathSegMovetoRel
 
4273
#########################################################################*/
 
4274
 
 
4275
/**
 
4276
 *
 
4277
 */
 
4278
class SVGPathSegMovetoRel : public SVGPathSeg
 
4279
{
 
4280
public:
 
4281
 
 
4282
    /**
 
4283
     *
 
4284
     */
 
4285
    virtual double getX()
 
4286
        { return x; }
 
4287
 
 
4288
    /**
 
4289
     *
 
4290
     */
 
4291
    virtual void setX(double val) throw (DOMException)
 
4292
        { x = val; }
 
4293
 
 
4294
    /**
 
4295
     *
 
4296
     */
 
4297
    virtual double getY()
 
4298
        { return y; }
 
4299
 
 
4300
    /**
 
4301
     *
 
4302
     */
 
4303
    virtual void setY(double val) throw (DOMException)
 
4304
        { y = val; }
 
4305
 
 
4306
    //##################
 
4307
    //# Non-API methods
 
4308
    //##################
 
4309
 
 
4310
    /**
 
4311
     *
 
4312
     */
 
4313
    SVGPathSegMovetoRel()
 
4314
        {
 
4315
        type = PATHSEG_MOVETO_REL;
 
4316
        x = y = 0.0;
 
4317
        }
 
4318
 
 
4319
 
 
4320
    /**
 
4321
     *
 
4322
     */
 
4323
    SVGPathSegMovetoRel(double xArg, double yArg)
 
4324
        {
 
4325
        type = PATHSEG_MOVETO_REL;
 
4326
        x = xArg; y = yArg;
 
4327
        }
 
4328
 
 
4329
    /**
 
4330
     *
 
4331
     */
 
4332
    SVGPathSegMovetoRel(const SVGPathSegMovetoRel &other) : SVGPathSeg(other)
 
4333
        {
 
4334
        type = PATHSEG_MOVETO_REL;
 
4335
        x = other.x; y = other.y;
 
4336
        }
 
4337
 
 
4338
    /**
 
4339
     *
 
4340
     */
 
4341
    virtual ~SVGPathSegMovetoRel() {}
 
4342
 
 
4343
protected:
 
4344
 
 
4345
    double x,y;
 
4346
};
 
4347
 
 
4348
 
 
4349
 
 
4350
 
 
4351
 
 
4352
 
 
4353
/*#########################################################################
 
4354
## SVGPathSegLinetoAbs
 
4355
#########################################################################*/
 
4356
 
 
4357
/**
 
4358
 *
 
4359
 */
 
4360
class SVGPathSegLinetoAbs : public SVGPathSeg
 
4361
{
 
4362
public:
 
4363
 
 
4364
    /**
 
4365
     *
 
4366
     */
 
4367
    virtual double getX()
 
4368
        { return x; }
 
4369
 
 
4370
    /**
 
4371
     *
 
4372
     */
 
4373
    virtual void setX(double val) throw (DOMException)
 
4374
        { x = val; }
 
4375
 
 
4376
    /**
 
4377
     *
 
4378
     */
 
4379
    virtual double getY()
 
4380
        { return y; }
 
4381
 
 
4382
    /**
 
4383
     *
 
4384
     */
 
4385
    virtual void setY(double val) throw (DOMException)
 
4386
        { y = val; }
 
4387
 
 
4388
    //##################
 
4389
    //# Non-API methods
 
4390
    //##################
 
4391
 
 
4392
    /**
 
4393
     *
 
4394
     */
 
4395
    SVGPathSegLinetoAbs()
 
4396
        {
 
4397
        type = PATHSEG_LINETO_ABS;
 
4398
        x = y = 0.0;
 
4399
        }
 
4400
 
 
4401
 
 
4402
    /**
 
4403
     *
 
4404
     */
 
4405
    SVGPathSegLinetoAbs(double xArg, double yArg)
 
4406
        {
 
4407
        type = PATHSEG_LINETO_ABS;
 
4408
        x = xArg; y = yArg;
 
4409
        }
 
4410
 
 
4411
    /**
 
4412
     *
 
4413
     */
 
4414
    SVGPathSegLinetoAbs(const SVGPathSegLinetoAbs &other) : SVGPathSeg(other)
 
4415
        {
 
4416
        type = PATHSEG_LINETO_ABS;
 
4417
        x = other.x; y = other.y;
 
4418
        }
 
4419
 
 
4420
    /**
 
4421
     *
 
4422
     */
 
4423
    virtual ~SVGPathSegLinetoAbs() {}
 
4424
 
 
4425
protected:
 
4426
 
 
4427
    double x,y;
 
4428
};
 
4429
 
 
4430
 
 
4431
 
 
4432
 
 
4433
 
 
4434
 
 
4435
/*#########################################################################
 
4436
## SVGPathSegLinetoRel
 
4437
#########################################################################*/
 
4438
 
 
4439
/**
 
4440
 *
 
4441
 */
 
4442
class SVGPathSegLinetoRel : public SVGPathSeg
 
4443
{
 
4444
public:
 
4445
 
 
4446
    /**
 
4447
     *
 
4448
     */
 
4449
    virtual double getX()
 
4450
        { return x; }
 
4451
 
 
4452
    /**
 
4453
     *
 
4454
     */
 
4455
    virtual void setX(double val) throw (DOMException)
 
4456
        { x = val; }
 
4457
 
 
4458
    /**
 
4459
     *
 
4460
     */
 
4461
    virtual double getY()
 
4462
        { return y; }
 
4463
 
 
4464
    /**
 
4465
     *
 
4466
     */
 
4467
    virtual void setY(double val) throw (DOMException)
 
4468
        { y = val; }
 
4469
 
 
4470
    //##################
 
4471
    //# Non-API methods
 
4472
    //##################
 
4473
 
 
4474
    /**
 
4475
     *
 
4476
     */
 
4477
    SVGPathSegLinetoRel()
 
4478
        {
 
4479
        type = PATHSEG_LINETO_REL;
 
4480
        x = y = 0.0;
 
4481
        }
 
4482
 
 
4483
 
 
4484
    /**
 
4485
     *
 
4486
     */
 
4487
    SVGPathSegLinetoRel(double xArg, double yArg)
 
4488
        {
 
4489
        type = PATHSEG_LINETO_REL;
 
4490
        x = xArg; y = yArg;
 
4491
        }
 
4492
 
 
4493
    /**
 
4494
     *
 
4495
     */
 
4496
    SVGPathSegLinetoRel(const SVGPathSegLinetoRel &other) : SVGPathSeg(other)
 
4497
        {
 
4498
        type = PATHSEG_LINETO_REL;
 
4499
        x = other.x; y = other.y;
 
4500
        }
 
4501
 
 
4502
    /**
 
4503
     *
 
4504
     */
 
4505
    virtual ~SVGPathSegLinetoRel() {}
 
4506
 
 
4507
protected:
 
4508
 
 
4509
    double x,y;
 
4510
};
 
4511
 
 
4512
 
 
4513
 
 
4514
 
 
4515
 
 
4516
 
 
4517
/*#########################################################################
 
4518
## SVGPathSegCurvetoCubicAbs
 
4519
#########################################################################*/
 
4520
 
 
4521
/**
 
4522
 *
 
4523
 */
 
4524
class SVGPathSegCurvetoCubicAbs : public SVGPathSeg
 
4525
{
 
4526
public:
 
4527
 
 
4528
    /**
 
4529
     *
 
4530
     */
 
4531
    virtual double getX()
 
4532
        { return x; }
 
4533
 
 
4534
    /**
 
4535
     *
 
4536
     */
 
4537
    virtual void setX(double val) throw (DOMException)
 
4538
        { x = val; }
 
4539
 
 
4540
    /**
 
4541
     *
 
4542
     */
 
4543
    virtual double getY()
 
4544
        { return y; }
 
4545
 
 
4546
    /**
 
4547
     *
 
4548
     */
 
4549
    virtual void setY(double val) throw (DOMException)
 
4550
        { y = val; }
 
4551
 
 
4552
    /**
 
4553
     *
 
4554
     */
 
4555
    virtual double getX1()
 
4556
        { return x1; }
 
4557
 
 
4558
    /**
 
4559
     *
 
4560
     */
 
4561
    virtual void setX1(double val) throw (DOMException)
 
4562
        { x1 = val; }
 
4563
 
 
4564
    /**
 
4565
     *
 
4566
     */
 
4567
    virtual double getY1()
 
4568
        { return y1; }
 
4569
 
 
4570
    /**
 
4571
     *
 
4572
     */
 
4573
    virtual void setY1(double val) throw (DOMException)
 
4574
        { y1 = val; }
 
4575
 
 
4576
 
 
4577
    /**
 
4578
     *
 
4579
     */
 
4580
    virtual double getX2()
 
4581
        { return x2; }
 
4582
 
 
4583
    /**
 
4584
     *
 
4585
     */
 
4586
    virtual void setX2(double val) throw (DOMException)
 
4587
        { x2 = val; }
 
4588
 
 
4589
    /**
 
4590
     *
 
4591
     */
 
4592
    virtual double getY2()
 
4593
        { return y2; }
 
4594
 
 
4595
    /**
 
4596
     *
 
4597
     */
 
4598
    virtual void setY2(double val) throw (DOMException)
 
4599
        { y2 = val; }
 
4600
 
 
4601
 
 
4602
    //##################
 
4603
    //# Non-API methods
 
4604
    //##################
 
4605
 
 
4606
 
 
4607
    /**
 
4608
     *
 
4609
     */
 
4610
    SVGPathSegCurvetoCubicAbs()
 
4611
        {
 
4612
        type = PATHSEG_CURVETO_CUBIC_ABS;
 
4613
        x = y = x1 = y1 = x2 = y2 = 0.0;
 
4614
        }
 
4615
 
 
4616
    /**
 
4617
     *
 
4618
     */
 
4619
    SVGPathSegCurvetoCubicAbs(double xArg,  double yArg,
 
4620
                              double x1Arg, double y1Arg,
 
4621
                              double x2Arg, double y2Arg)
 
4622
        {
 
4623
        type = PATHSEG_CURVETO_CUBIC_ABS;
 
4624
        x  = xArg;   y  = yArg;
 
4625
        x1 = x1Arg;  y1 = y1Arg;
 
4626
        x2 = x2Arg;  y2 = y2Arg;
 
4627
        }
 
4628
 
 
4629
    /**
 
4630
     *
 
4631
     */
 
4632
    SVGPathSegCurvetoCubicAbs(const SVGPathSegCurvetoCubicAbs &other)
 
4633
                     : SVGPathSeg(other)
 
4634
        {
 
4635
        type = PATHSEG_CURVETO_CUBIC_ABS;
 
4636
        x  = other.x;  y  = other.y;
 
4637
        x1 = other.x1; y1 = other.y1;
 
4638
        x2 = other.x2; y2 = other.y2;
 
4639
        }
 
4640
 
 
4641
    /**
 
4642
     *
 
4643
     */
 
4644
    virtual ~SVGPathSegCurvetoCubicAbs() {}
 
4645
 
 
4646
protected:
 
4647
 
 
4648
    double x, y, x1, y1, x2, y2;
 
4649
 
 
4650
};
 
4651
 
 
4652
 
 
4653
 
 
4654
 
 
4655
 
 
4656
 
 
4657
/*#########################################################################
 
4658
## SVGPathSegCurvetoCubicRel
 
4659
#########################################################################*/
 
4660
 
 
4661
/**
 
4662
 *
 
4663
 */
 
4664
class SVGPathSegCurvetoCubicRel : public SVGPathSeg
 
4665
{
 
4666
public:
 
4667
 
 
4668
    /**
 
4669
     *
 
4670
     */
 
4671
    virtual double getX()
 
4672
        { return x; }
 
4673
 
 
4674
    /**
 
4675
     *
 
4676
     */
 
4677
    virtual void setX(double val) throw (DOMException)
 
4678
        { x = val; }
 
4679
 
 
4680
    /**
 
4681
     *
 
4682
     */
 
4683
    virtual double getY()
 
4684
        { return y; }
 
4685
 
 
4686
    /**
 
4687
     *
 
4688
     */
 
4689
    virtual void setY(double val) throw (DOMException)
 
4690
        { y = val; }
 
4691
 
 
4692
    /**
 
4693
     *
 
4694
     */
 
4695
    virtual double getX1()
 
4696
        { return x1; }
 
4697
 
 
4698
    /**
 
4699
     *
 
4700
     */
 
4701
    virtual void setX1(double val) throw (DOMException)
 
4702
        { x1 = val; }
 
4703
 
 
4704
    /**
 
4705
     *
 
4706
     */
 
4707
    virtual double getY1()
 
4708
        { return y1; }
 
4709
 
 
4710
    /**
 
4711
     *
 
4712
     */
 
4713
    virtual void setY1(double val) throw (DOMException)
 
4714
        { y1 = val; }
 
4715
 
 
4716
 
 
4717
    /**
 
4718
     *
 
4719
     */
 
4720
    virtual double getX2()
 
4721
        { return x2; }
 
4722
 
 
4723
    /**
 
4724
     *
 
4725
     */
 
4726
    virtual void setX2(double val) throw (DOMException)
 
4727
        { x2 = val; }
 
4728
 
 
4729
    /**
 
4730
     *
 
4731
     */
 
4732
    virtual double getY2()
 
4733
        { return y2; }
 
4734
 
 
4735
    /**
 
4736
     *
 
4737
     */
 
4738
    virtual void setY2(double val) throw (DOMException)
 
4739
        { y2 = val; }
 
4740
 
 
4741
 
 
4742
    //##################
 
4743
    //# Non-API methods
 
4744
    //##################
 
4745
 
 
4746
 
 
4747
    /**
 
4748
     *
 
4749
     */
 
4750
    SVGPathSegCurvetoCubicRel()
 
4751
        {
 
4752
        type = PATHSEG_CURVETO_CUBIC_REL;
 
4753
        x = y = x1 = y1 = x2 = y2 = 0.0;
 
4754
        }
 
4755
 
 
4756
 
 
4757
    /**
 
4758
     *
 
4759
     */
 
4760
    SVGPathSegCurvetoCubicRel(double xArg,  double yArg,
 
4761
                              double x1Arg, double y1Arg,
 
4762
                              double x2Arg, double y2Arg)
 
4763
        {
 
4764
        type = PATHSEG_CURVETO_CUBIC_REL;
 
4765
        x  = xArg;   y  = yArg;
 
4766
        x1 = x1Arg;  y1 = y1Arg;
 
4767
        x2 = x2Arg;  y2 = y2Arg;
 
4768
        }
 
4769
 
 
4770
    /**
 
4771
     *
 
4772
     */
 
4773
    SVGPathSegCurvetoCubicRel(const SVGPathSegCurvetoCubicRel &other)
 
4774
                     : SVGPathSeg(other)
 
4775
        {
 
4776
        type = PATHSEG_CURVETO_CUBIC_REL;
 
4777
        x  = other.x;  y  = other.y;
 
4778
        x1 = other.x1; y1 = other.y1;
 
4779
        x2 = other.x2; y2 = other.y2;
 
4780
        }
 
4781
 
 
4782
    /**
 
4783
     *
 
4784
     */
 
4785
    virtual ~SVGPathSegCurvetoCubicRel() {}
 
4786
 
 
4787
protected:
 
4788
 
 
4789
    double x, y, x1, y1, x2, y2;
 
4790
 
 
4791
};
 
4792
 
 
4793
 
 
4794
 
 
4795
 
 
4796
 
 
4797
 
 
4798
/*#########################################################################
 
4799
## SVGPathSegCurvetoQuadraticAbs
 
4800
#########################################################################*/
 
4801
 
 
4802
/**
 
4803
 *
 
4804
 */
 
4805
class SVGPathSegCurvetoQuadraticAbs : public SVGPathSeg
 
4806
{
 
4807
public:
 
4808
 
 
4809
    /**
 
4810
     *
 
4811
     */
 
4812
    virtual double getX()
 
4813
        { return x; }
 
4814
 
 
4815
    /**
 
4816
     *
 
4817
     */
 
4818
    virtual void setX(double val) throw (DOMException)
 
4819
        { x = val; }
 
4820
 
 
4821
    /**
 
4822
     *
 
4823
     */
 
4824
    virtual double getY()
 
4825
        { return y; }
 
4826
 
 
4827
    /**
 
4828
     *
 
4829
     */
 
4830
    virtual void setY(double val) throw (DOMException)
 
4831
        { y = val; }
 
4832
 
 
4833
    /**
 
4834
     *
 
4835
     */
 
4836
    virtual double getX1()
 
4837
        { return x1; }
 
4838
 
 
4839
    /**
 
4840
     *
 
4841
     */
 
4842
    virtual void setX1(double val) throw (DOMException)
 
4843
        { x1 = val; }
 
4844
 
 
4845
    /**
 
4846
     *
 
4847
     */
 
4848
    virtual double getY1()
 
4849
        { return y1; }
 
4850
 
 
4851
    /**
 
4852
     *
 
4853
     */
 
4854
    virtual void setY1(double val) throw (DOMException)
 
4855
        { y1 = val; }
 
4856
 
 
4857
 
 
4858
    //##################
 
4859
    //# Non-API methods
 
4860
    //##################
 
4861
 
 
4862
 
 
4863
    /**
 
4864
     *
 
4865
     */
 
4866
    SVGPathSegCurvetoQuadraticAbs()
 
4867
        {
 
4868
        type = PATHSEG_CURVETO_QUADRATIC_ABS;
 
4869
        x = y = x1 = y1 = 0.0;
 
4870
        }
 
4871
 
 
4872
    /**
 
4873
     *
 
4874
     */
 
4875
    SVGPathSegCurvetoQuadraticAbs(double xArg,  double yArg,
 
4876
                              double x1Arg, double y1Arg)
 
4877
        {
 
4878
        type = PATHSEG_CURVETO_QUADRATIC_ABS;
 
4879
        x  = xArg;   y  = yArg;
 
4880
        x1 = x1Arg;  y1 = y1Arg;
 
4881
        }
 
4882
 
 
4883
    /**
 
4884
     *
 
4885
     */
 
4886
    SVGPathSegCurvetoQuadraticAbs(const SVGPathSegCurvetoQuadraticAbs &other)
 
4887
                     : SVGPathSeg(other)
 
4888
        {
 
4889
        type = PATHSEG_CURVETO_QUADRATIC_ABS;
 
4890
        x  = other.x;  y  = other.y;
 
4891
        x1 = other.x1; y1 = other.y1;
 
4892
        }
 
4893
 
 
4894
    /**
 
4895
     *
 
4896
     */
 
4897
    virtual ~SVGPathSegCurvetoQuadraticAbs() {}
 
4898
 
 
4899
protected:
 
4900
 
 
4901
    double x, y, x1, y1;
 
4902
 
 
4903
};
 
4904
 
 
4905
 
 
4906
 
 
4907
 
 
4908
 
 
4909
 
 
4910
/*#########################################################################
 
4911
## SVGPathSegCurvetoQuadraticRel
 
4912
#########################################################################*/
 
4913
 
 
4914
/**
 
4915
 *
 
4916
 */
 
4917
class SVGPathSegCurvetoQuadraticRel : public SVGPathSeg
 
4918
{
 
4919
public:
 
4920
 
 
4921
    /**
 
4922
     *
 
4923
     */
 
4924
    virtual double getX()
 
4925
        { return x; }
 
4926
 
 
4927
    /**
 
4928
     *
 
4929
     */
 
4930
    virtual void setX(double val) throw (DOMException)
 
4931
        { x = val; }
 
4932
 
 
4933
    /**
 
4934
     *
 
4935
     */
 
4936
    virtual double getY()
 
4937
        { return y; }
 
4938
 
 
4939
    /**
 
4940
     *
 
4941
     */
 
4942
    virtual void setY(double val) throw (DOMException)
 
4943
        { y = val; }
 
4944
 
 
4945
    /**
 
4946
     *
 
4947
     */
 
4948
    virtual double getX1()
 
4949
        { return x1; }
 
4950
 
 
4951
    /**
 
4952
     *
 
4953
     */
 
4954
    virtual void setX1(double val) throw (DOMException)
 
4955
        { x1 = val; }
 
4956
 
 
4957
    /**
 
4958
     *
 
4959
     */
 
4960
    virtual double getY1()
 
4961
        { return y1; }
 
4962
 
 
4963
    /**
 
4964
     *
 
4965
     */
 
4966
    virtual void setY1(double val) throw (DOMException)
 
4967
        { y1 = val; }
 
4968
 
 
4969
 
 
4970
    //##################
 
4971
    //# Non-API methods
 
4972
    //##################
 
4973
 
 
4974
 
 
4975
    /**
 
4976
     *
 
4977
     */
 
4978
    SVGPathSegCurvetoQuadraticRel()
 
4979
        {
 
4980
        type = PATHSEG_CURVETO_QUADRATIC_REL;
 
4981
        x = y = x1 = y1 = 0.0;
 
4982
        }
 
4983
 
 
4984
 
 
4985
    /**
 
4986
     *
 
4987
     */
 
4988
    SVGPathSegCurvetoQuadraticRel(double xArg,  double yArg,
 
4989
                                  double x1Arg, double y1Arg)
 
4990
        {
 
4991
        type = PATHSEG_CURVETO_QUADRATIC_REL;
 
4992
        x  = xArg;   y  = yArg;
 
4993
        x1 = x1Arg;  y1 = y1Arg;
 
4994
        }
 
4995
 
 
4996
    /**
 
4997
     *
 
4998
     */
 
4999
    SVGPathSegCurvetoQuadraticRel(const SVGPathSegCurvetoQuadraticRel &other)
 
5000
                     : SVGPathSeg(other)
 
5001
        {
 
5002
        type = PATHSEG_CURVETO_QUADRATIC_REL;
 
5003
        x  = other.x;  y  = other.y;
 
5004
        x1 = other.x1; y1 = other.y1;
 
5005
        }
 
5006
 
 
5007
    /**
 
5008
     *
 
5009
     */
 
5010
    virtual ~SVGPathSegCurvetoQuadraticRel() {}
 
5011
 
 
5012
protected:
 
5013
 
 
5014
    double x, y, x1, y1;
 
5015
 
 
5016
};
 
5017
 
 
5018
 
 
5019
 
 
5020
 
 
5021
 
 
5022
 
 
5023
/*#########################################################################
 
5024
## SVGPathSegArcAbs
 
5025
#########################################################################*/
 
5026
 
 
5027
/**
 
5028
 *
 
5029
 */
 
5030
class SVGPathSegArcAbs : public SVGPathSeg
 
5031
{
 
5032
public:
 
5033
 
 
5034
    /**
 
5035
     *
 
5036
     */
 
5037
    virtual double getX()
 
5038
        { return x; }
 
5039
 
 
5040
    /**
 
5041
     *
 
5042
     */
 
5043
    virtual void setX(double val) throw (DOMException)
 
5044
        { x = val; }
 
5045
 
 
5046
    /**
 
5047
     *
 
5048
     */
 
5049
    virtual double getY()
 
5050
        { return y; }
 
5051
 
 
5052
    /**
 
5053
     *
 
5054
     */
 
5055
    virtual void setY(double val) throw (DOMException)
 
5056
        { y = val; }
 
5057
 
 
5058
    /**
 
5059
     *
 
5060
     */
 
5061
    virtual double getR1()
 
5062
        { return r1; }
 
5063
 
 
5064
    /**
 
5065
     *
 
5066
     */
 
5067
    virtual void setR1(double val) throw (DOMException)
 
5068
        { r1 = val; }
 
5069
 
 
5070
    /**
 
5071
     *
 
5072
     */
 
5073
    virtual double getR2()
 
5074
        { return r2; }
 
5075
 
 
5076
    /**
 
5077
     *
 
5078
     */
 
5079
    virtual void setR2(double val) throw (DOMException)
 
5080
        { r2 = val; }
 
5081
 
 
5082
    /**
 
5083
     *
 
5084
     */
 
5085
    virtual double getAngle()
 
5086
        { return angle; }
 
5087
 
 
5088
    /**
 
5089
     *
 
5090
     */
 
5091
    virtual void setAngle(double val) throw (DOMException)
 
5092
        { angle = val; }
 
5093
 
 
5094
    /**
 
5095
     *
 
5096
     */
 
5097
    virtual bool getLargeArcFlag()
 
5098
        { return largeArcFlag; }
 
5099
 
 
5100
    /**
 
5101
     *
 
5102
     */
 
5103
    virtual void setLargeArcFlag(bool val) throw (DOMException)
 
5104
        { largeArcFlag = val; }
 
5105
 
 
5106
    /**
 
5107
     *
 
5108
     */
 
5109
    virtual bool getSweepFlag()
 
5110
        { return sweepFlag; }
 
5111
 
 
5112
    /**
 
5113
     *
 
5114
     */
 
5115
    virtual void setSweepFlag(bool val) throw (DOMException)
 
5116
        { sweepFlag = val; }
 
5117
 
 
5118
    //##################
 
5119
    //# Non-API methods
 
5120
    //##################
 
5121
 
 
5122
 
 
5123
    /**
 
5124
     *
 
5125
     */
 
5126
    SVGPathSegArcAbs()
 
5127
        {
 
5128
        type = PATHSEG_ARC_ABS;
 
5129
        x = y = r1 = r2 = angle = 0.0;
 
5130
        largeArcFlag = sweepFlag = false;
 
5131
        }
 
5132
 
 
5133
    /**
 
5134
     *
 
5135
     */
 
5136
    SVGPathSegArcAbs(double xArg,  double yArg,
 
5137
                     double r1Arg, double r2Arg,
 
5138
                     double angleArg,
 
5139
                     bool largeArcFlagArg,
 
5140
                     bool sweepFlagArg )
 
5141
 
 
5142
        {
 
5143
        type = PATHSEG_ARC_ABS;
 
5144
        x  = xArg;   y  = yArg;
 
5145
        r1 = r1Arg;  r2 = r2Arg;
 
5146
        angle        = angleArg;
 
5147
        largeArcFlag = largeArcFlagArg;
 
5148
        sweepFlag    = sweepFlagArg;
 
5149
        }
 
5150
 
 
5151
    /**
 
5152
     *
 
5153
     */
 
5154
    SVGPathSegArcAbs(const SVGPathSegArcAbs &other)
 
5155
                     : SVGPathSeg(other)
 
5156
        {
 
5157
        type = PATHSEG_ARC_ABS;
 
5158
        x  = other.x;  y  = other.y;
 
5159
        r1 = other.r1; r2 = other.r2;
 
5160
        angle        = other.angle;
 
5161
        largeArcFlag = other.largeArcFlag;
 
5162
        sweepFlag    = other.sweepFlag;
 
5163
        }
 
5164
 
 
5165
    /**
 
5166
     *
 
5167
     */
 
5168
    virtual ~SVGPathSegArcAbs() {}
 
5169
 
 
5170
protected:
 
5171
 
 
5172
    double x, y, r1, r2, angle;
 
5173
    bool largeArcFlag;
 
5174
    bool sweepFlag;
 
5175
 
 
5176
};
 
5177
 
 
5178
 
 
5179
 
 
5180
/*#########################################################################
 
5181
## SVGPathSegArcRel
 
5182
#########################################################################*/
 
5183
 
 
5184
/**
 
5185
 *
 
5186
 */
 
5187
class SVGPathSegArcRel : public SVGPathSeg
 
5188
{
 
5189
public:
 
5190
 
 
5191
    /**
 
5192
     *
 
5193
     */
 
5194
    virtual double getX()
 
5195
        { return x; }
 
5196
 
 
5197
    /**
 
5198
     *
 
5199
     */
 
5200
    virtual void setX(double val) throw (DOMException)
 
5201
        { x = val; }
 
5202
 
 
5203
    /**
 
5204
     *
 
5205
     */
 
5206
    virtual double getY()
 
5207
        { return y; }
 
5208
 
 
5209
    /**
 
5210
     *
 
5211
     */
 
5212
    virtual void setY(double val) throw (DOMException)
 
5213
        { y = val; }
 
5214
 
 
5215
    /**
 
5216
     *
 
5217
     */
 
5218
    virtual double getR1()
 
5219
        { return r1; }
 
5220
 
 
5221
    /**
 
5222
     *
 
5223
     */
 
5224
    virtual void setR1(double val) throw (DOMException)
 
5225
        { r1 = val; }
 
5226
 
 
5227
    /**
 
5228
     *
 
5229
     */
 
5230
    virtual double getR2()
 
5231
        { return r2; }
 
5232
 
 
5233
    /**
 
5234
     *
 
5235
     */
 
5236
    virtual void setR2(double val) throw (DOMException)
 
5237
        { r2 = val; }
 
5238
 
 
5239
    /**
 
5240
     *
 
5241
     */
 
5242
    virtual double getAngle()
 
5243
        { return angle; }
 
5244
 
 
5245
    /**
 
5246
     *
 
5247
     */
 
5248
    virtual void setAngle(double val) throw (DOMException)
 
5249
        { angle = val; }
 
5250
 
 
5251
    /**
 
5252
     *
 
5253
     */
 
5254
    virtual bool getLargeArcFlag()
 
5255
        { return largeArcFlag; }
 
5256
 
 
5257
    /**
 
5258
     *
 
5259
     */
 
5260
    virtual void setLargeArcFlag(bool val) throw (DOMException)
 
5261
        { largeArcFlag = val; }
 
5262
 
 
5263
    /**
 
5264
     *
 
5265
     */
 
5266
    virtual bool getSweepFlag()
 
5267
        { return sweepFlag; }
 
5268
 
 
5269
    /**
 
5270
     *
 
5271
     */
 
5272
    virtual void setSweepFlag(bool val) throw (DOMException)
 
5273
        { sweepFlag = val; }
 
5274
 
 
5275
    //##################
 
5276
    //# Non-API methods
 
5277
    //##################
 
5278
 
 
5279
 
 
5280
    /**
 
5281
     *
 
5282
     */
 
5283
    SVGPathSegArcRel()
 
5284
        {
 
5285
        type = PATHSEG_ARC_REL;
 
5286
        x = y = r1 = r2 = angle = 0.0;
 
5287
        largeArcFlag = sweepFlag = false;
 
5288
        }
 
5289
 
 
5290
 
 
5291
    /**
 
5292
     *
 
5293
     */
 
5294
    SVGPathSegArcRel(double xArg, double yArg,
 
5295
                     double r1Arg, double r2Arg,
 
5296
                     double angleArg,
 
5297
                     bool largeArcFlagArg,
 
5298
                     bool sweepFlagArg )
 
5299
 
 
5300
        {
 
5301
        type = PATHSEG_ARC_REL;
 
5302
        x  = xArg;   y  = yArg;
 
5303
        r1 = r1Arg;  r2 = r2Arg;
 
5304
        angle        = angleArg;
 
5305
        largeArcFlag = largeArcFlagArg;
 
5306
        sweepFlag    = sweepFlagArg;
 
5307
        }
 
5308
 
 
5309
    /**
 
5310
     *
 
5311
     */
 
5312
    SVGPathSegArcRel(const SVGPathSegArcRel &other)
 
5313
                     : SVGPathSeg(other)
 
5314
        {
 
5315
        type = PATHSEG_ARC_REL;
 
5316
        x  = other.x;  y  = other.y;
 
5317
        r1 = other.r1; r2 = other.r2;
 
5318
        angle        = other.angle;
 
5319
        largeArcFlag = other.largeArcFlag;
 
5320
        sweepFlag    = other.sweepFlag;
 
5321
        }
 
5322
 
 
5323
    /**
 
5324
     *
 
5325
     */
 
5326
    virtual ~SVGPathSegArcRel() {}
 
5327
 
 
5328
protected:
 
5329
 
 
5330
    double x, y, r1, r2, angle;
 
5331
    bool largeArcFlag;
 
5332
    bool sweepFlag;
 
5333
 
 
5334
};
 
5335
 
 
5336
 
 
5337
 
 
5338
 
 
5339
 
 
5340
 
 
5341
/*#########################################################################
 
5342
## SVGPathSegLinetoHorizontalAbs
 
5343
#########################################################################*/
 
5344
 
 
5345
/**
 
5346
 *
 
5347
 */
 
5348
class SVGPathSegLinetoHorizontalAbs : public SVGPathSeg
 
5349
{
 
5350
public:
 
5351
 
 
5352
    /**
 
5353
     *
 
5354
     */
 
5355
    virtual double getX()
 
5356
        { return x; }
 
5357
 
 
5358
    /**
 
5359
     *
 
5360
     */
 
5361
    virtual void setX(double val) throw (DOMException)
 
5362
        { x = val; }
 
5363
 
 
5364
    //##################
 
5365
    //# Non-API methods
 
5366
    //##################
 
5367
 
 
5368
    /**
 
5369
     *
 
5370
     */
 
5371
    SVGPathSegLinetoHorizontalAbs()
 
5372
        {
 
5373
        type = PATHSEG_LINETO_HORIZONTAL_ABS;
 
5374
        x = 0.0;
 
5375
        }
 
5376
 
 
5377
 
 
5378
    /**
 
5379
     *
 
5380
     */
 
5381
    SVGPathSegLinetoHorizontalAbs(double xArg)
 
5382
        {
 
5383
        type = PATHSEG_LINETO_HORIZONTAL_ABS;
 
5384
        x = xArg;
 
5385
        }
 
5386
 
 
5387
    /**
 
5388
     *
 
5389
     */
 
5390
    SVGPathSegLinetoHorizontalAbs(const SVGPathSegLinetoHorizontalAbs &other)
 
5391
                     : SVGPathSeg(other)
 
5392
        {
 
5393
        type = PATHSEG_LINETO_HORIZONTAL_ABS;
 
5394
        x = other.x;
 
5395
        }
 
5396
 
 
5397
    /**
 
5398
     *
 
5399
     */
 
5400
    virtual ~SVGPathSegLinetoHorizontalAbs() {}
 
5401
 
 
5402
protected:
 
5403
 
 
5404
    double x;
 
5405
 
 
5406
};
 
5407
 
 
5408
 
 
5409
 
 
5410
 
 
5411
 
 
5412
 
 
5413
/*#########################################################################
 
5414
## SVGPathSegLinetoHorizontalRel
 
5415
#########################################################################*/
 
5416
 
 
5417
/**
 
5418
 *
 
5419
 */
 
5420
class SVGPathSegLinetoHorizontalRel : public SVGPathSeg
 
5421
{
 
5422
public:
 
5423
 
 
5424
    /**
 
5425
     *
 
5426
     */
 
5427
    virtual double getX()
 
5428
        { return x; }
 
5429
 
 
5430
    /**
 
5431
     *
 
5432
     */
 
5433
    virtual void setX(double val) throw (DOMException)
 
5434
        { x = val; }
 
5435
 
 
5436
    //##################
 
5437
    //# Non-API methods
 
5438
    //##################
 
5439
 
 
5440
    /**
 
5441
     *
 
5442
     */
 
5443
    SVGPathSegLinetoHorizontalRel()
 
5444
        {
 
5445
        type = PATHSEG_LINETO_HORIZONTAL_REL;
 
5446
        x = 0.0;
 
5447
        }
 
5448
 
 
5449
 
 
5450
    /**
 
5451
     *
 
5452
     */
 
5453
    SVGPathSegLinetoHorizontalRel(double xArg)
 
5454
        {
 
5455
        type = PATHSEG_LINETO_HORIZONTAL_REL;
 
5456
        x = xArg;
 
5457
        }
 
5458
 
 
5459
    /**
 
5460
     *
 
5461
     */
 
5462
    SVGPathSegLinetoHorizontalRel(const SVGPathSegLinetoHorizontalRel &other)
 
5463
                     : SVGPathSeg(other)
 
5464
        {
 
5465
        type = PATHSEG_LINETO_HORIZONTAL_REL;
 
5466
        x = other.x;
 
5467
        }
 
5468
 
 
5469
    /**
 
5470
     *
 
5471
     */
 
5472
    virtual ~SVGPathSegLinetoHorizontalRel() {}
 
5473
 
 
5474
protected:
 
5475
 
 
5476
    double x;
 
5477
 
 
5478
};
 
5479
 
 
5480
 
 
5481
 
 
5482
/*#########################################################################
 
5483
## SVGPathSegLinetoVerticalAbs
 
5484
#########################################################################*/
 
5485
 
 
5486
/**
 
5487
 *
 
5488
 */
 
5489
class SVGPathSegLinetoVerticalAbs : public SVGPathSeg
 
5490
{
 
5491
public:
 
5492
 
 
5493
    /**
 
5494
     *
 
5495
     */
 
5496
    virtual double getY()
 
5497
        { return y; }
 
5498
 
 
5499
    /**
 
5500
     *
 
5501
     */
 
5502
    virtual void setY(double val) throw (DOMException)
 
5503
        { y = val; }
 
5504
 
 
5505
    //##################
 
5506
    //# Non-API methods
 
5507
    //##################
 
5508
 
 
5509
    /**
 
5510
     *
 
5511
     */
 
5512
    SVGPathSegLinetoVerticalAbs()
 
5513
        {
 
5514
        type = PATHSEG_LINETO_VERTICAL_ABS;
 
5515
        y = 0.0;
 
5516
        }
 
5517
 
 
5518
 
 
5519
    /**
 
5520
     *
 
5521
     */
 
5522
    SVGPathSegLinetoVerticalAbs(double yArg)
 
5523
        {
 
5524
        type = PATHSEG_LINETO_VERTICAL_ABS;
 
5525
        y = yArg;
 
5526
        }
 
5527
 
 
5528
    /**
 
5529
     *
 
5530
     */
 
5531
    SVGPathSegLinetoVerticalAbs(const SVGPathSegLinetoVerticalAbs &other)
 
5532
                     : SVGPathSeg(other)
 
5533
        {
 
5534
        type = PATHSEG_LINETO_VERTICAL_ABS;
 
5535
        y = other.y;
 
5536
        }
 
5537
 
 
5538
    /**
 
5539
     *
 
5540
     */
 
5541
    virtual ~SVGPathSegLinetoVerticalAbs() {}
 
5542
 
 
5543
protected:
 
5544
 
 
5545
    double y;
 
5546
 
 
5547
};
 
5548
 
 
5549
 
 
5550
 
 
5551
/*#########################################################################
 
5552
## SVGPathSegLinetoVerticalRel
 
5553
#########################################################################*/
 
5554
 
 
5555
/**
 
5556
 *
 
5557
 */
 
5558
class SVGPathSegLinetoVerticalRel : public SVGPathSeg
 
5559
{
 
5560
public:
 
5561
 
 
5562
    /**
 
5563
     *
 
5564
     */
 
5565
    virtual double getY()
 
5566
        { return y; }
 
5567
 
 
5568
    /**
 
5569
     *
 
5570
     */
 
5571
    virtual void setY(double val) throw (DOMException)
 
5572
        { y = val; }
 
5573
 
 
5574
    //##################
 
5575
    //# Non-API methods
 
5576
    //##################
 
5577
 
 
5578
    /**
 
5579
     *
 
5580
     */
 
5581
    SVGPathSegLinetoVerticalRel()
 
5582
        {
 
5583
        type = PATHSEG_LINETO_VERTICAL_REL;
 
5584
        y = 0.0;
 
5585
        }
 
5586
 
 
5587
 
 
5588
    /**
 
5589
     *
 
5590
     */
 
5591
    SVGPathSegLinetoVerticalRel(double yArg)
 
5592
        {
 
5593
        type = PATHSEG_LINETO_VERTICAL_REL;
 
5594
        y = yArg;
 
5595
        }
 
5596
 
 
5597
    /**
 
5598
     *
 
5599
     */
 
5600
    SVGPathSegLinetoVerticalRel(const SVGPathSegLinetoVerticalRel &other)
 
5601
                     : SVGPathSeg(other)
 
5602
        {
 
5603
        type = PATHSEG_LINETO_VERTICAL_REL;
 
5604
        y = other.y;
 
5605
        }
 
5606
 
 
5607
    /**
 
5608
     *
 
5609
     */
 
5610
    virtual ~SVGPathSegLinetoVerticalRel() {}
 
5611
 
 
5612
protected:
 
5613
 
 
5614
    double y;
 
5615
 
 
5616
};
 
5617
 
 
5618
 
 
5619
 
 
5620
 
 
5621
 
 
5622
 
 
5623
/*#########################################################################
 
5624
## SVGPathSegCurvetoCubicSmoothAbs
 
5625
#########################################################################*/
 
5626
 
 
5627
/**
 
5628
 *
 
5629
 */
 
5630
class SVGPathSegCurvetoCubicSmoothAbs : public SVGPathSeg
 
5631
{
 
5632
public:
 
5633
 
 
5634
    /**
 
5635
     *
 
5636
     */
 
5637
    virtual double getX()
 
5638
        { return x; }
 
5639
 
 
5640
    /**
 
5641
     *
 
5642
     */
 
5643
    virtual void setX(double val) throw (DOMException)
 
5644
        { x = val; }
 
5645
 
 
5646
    /**
 
5647
     *
 
5648
     */
 
5649
    virtual double getY()
 
5650
        { return y; }
 
5651
 
 
5652
    /**
 
5653
     *
 
5654
     */
 
5655
    virtual void setY(double val) throw (DOMException)
 
5656
        { y = val; }
 
5657
 
 
5658
    /**
 
5659
     *
 
5660
     */
 
5661
    virtual double getX2()
 
5662
        { return x2; }
 
5663
 
 
5664
    /**
 
5665
     *
 
5666
     */
 
5667
    virtual void setX2(double val) throw (DOMException)
 
5668
        { x2 = val; }
 
5669
 
 
5670
    /**
 
5671
     *
 
5672
     */
 
5673
    virtual double getY2()
 
5674
        { return y2; }
 
5675
 
 
5676
    /**
 
5677
     *
 
5678
     */
 
5679
    virtual void setY2(double val) throw (DOMException)
 
5680
        { y2 = val; }
 
5681
 
 
5682
 
 
5683
    //##################
 
5684
    //# Non-API methods
 
5685
    //##################
 
5686
 
 
5687
    /**
 
5688
     *
 
5689
     */
 
5690
    SVGPathSegCurvetoCubicSmoothAbs()
 
5691
        {
 
5692
        type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
 
5693
        x = y = x2 = y2 = 0.0;
 
5694
        }
 
5695
 
 
5696
 
 
5697
    /**
 
5698
     *
 
5699
     */
 
5700
    SVGPathSegCurvetoCubicSmoothAbs(double xArg,   double yArg,
 
5701
                                    double x2Arg, double y2Arg)
 
5702
        {
 
5703
        type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
 
5704
        x  = xArg;    y  = yArg;
 
5705
        x2 = x2Arg;   y2 = y2Arg;
 
5706
        }
 
5707
 
 
5708
    /**
 
5709
     *
 
5710
     */
 
5711
    SVGPathSegCurvetoCubicSmoothAbs(const SVGPathSegCurvetoCubicSmoothAbs &other)
 
5712
                     : SVGPathSeg(other)
 
5713
        {
 
5714
        type = PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;
 
5715
        x  = other.x;  y  = other.y;
 
5716
        x2 = other.x2; y2 = other.y2;
 
5717
        }
 
5718
 
 
5719
    /**
 
5720
     *
 
5721
     */
 
5722
    virtual ~SVGPathSegCurvetoCubicSmoothAbs() {}
 
5723
 
 
5724
protected:
 
5725
 
 
5726
    double x, y, x2, y2;
 
5727
 
 
5728
};
 
5729
 
 
5730
 
 
5731
 
 
5732
/*#########################################################################
 
5733
## SVGPathSegCurvetoCubicSmoothRel
 
5734
#########################################################################*/
 
5735
 
 
5736
/**
 
5737
 *
 
5738
 */
 
5739
class SVGPathSegCurvetoCubicSmoothRel : public SVGPathSeg
 
5740
{
 
5741
public:
 
5742
 
 
5743
    /**
 
5744
     *
 
5745
     */
 
5746
    virtual double getX()
 
5747
        { return x; }
 
5748
 
 
5749
    /**
 
5750
     *
 
5751
     */
 
5752
    virtual void setX(double val) throw (DOMException)
 
5753
        { x = val; }
 
5754
 
 
5755
    /**
 
5756
     *
 
5757
     */
 
5758
    virtual double getY()
 
5759
        { return y; }
 
5760
 
 
5761
    /**
 
5762
     *
 
5763
     */
 
5764
    virtual void setY(double val) throw (DOMException)
 
5765
        { y = val; }
 
5766
 
 
5767
    /**
 
5768
     *
 
5769
     */
 
5770
    virtual double getX2()
 
5771
        { return x2; }
 
5772
 
 
5773
    /**
 
5774
     *
 
5775
     */
 
5776
    virtual void setX2(double val) throw (DOMException)
 
5777
        { x2 = val; }
 
5778
 
 
5779
    /**
 
5780
     *
 
5781
     */
 
5782
    virtual double getY2()
 
5783
        { return y2; }
 
5784
 
 
5785
    /**
 
5786
     *
 
5787
     */
 
5788
    virtual void setY2(double val) throw (DOMException)
 
5789
        { y2 = val; }
 
5790
 
 
5791
 
 
5792
    //##################
 
5793
    //# Non-API methods
 
5794
    //##################
 
5795
 
 
5796
    /**
 
5797
     *
 
5798
     */
 
5799
    SVGPathSegCurvetoCubicSmoothRel()
 
5800
        {
 
5801
        type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
 
5802
        x = y = x2 = y2 = 0.0;
 
5803
        }
 
5804
 
 
5805
 
 
5806
    /**
 
5807
     *
 
5808
     */
 
5809
    SVGPathSegCurvetoCubicSmoothRel(double xArg,   double yArg,
 
5810
                                    double x2Arg, double y2Arg)
 
5811
        {
 
5812
        type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
 
5813
        x  = xArg;    y  = yArg;
 
5814
        x2 = x2Arg;   y2 = y2Arg;
 
5815
        }
 
5816
 
 
5817
    /**
 
5818
     *
 
5819
     */
 
5820
    SVGPathSegCurvetoCubicSmoothRel(const SVGPathSegCurvetoCubicSmoothRel &other)
 
5821
                     : SVGPathSeg(other)
 
5822
        {
 
5823
        type = PATHSEG_CURVETO_CUBIC_SMOOTH_REL;
 
5824
        x  = other.x;  y  = other.y;
 
5825
        x2 = other.x2; y2 = other.y2;
 
5826
        }
 
5827
 
 
5828
    /**
 
5829
     *
 
5830
     */
 
5831
    virtual ~SVGPathSegCurvetoCubicSmoothRel() {}
 
5832
 
 
5833
protected:
 
5834
 
 
5835
    double x, y, x2, y2;
 
5836
 
 
5837
};
 
5838
 
 
5839
 
 
5840
 
 
5841
 
 
5842
 
 
5843
 
 
5844
/*#########################################################################
 
5845
## SVGPathSegCurvetoQuadraticSmoothAbs
 
5846
#########################################################################*/
 
5847
 
 
5848
/**
 
5849
 *
 
5850
 */
 
5851
class SVGPathSegCurvetoQuadraticSmoothAbs : public SVGPathSeg
 
5852
{
 
5853
public:
 
5854
 
 
5855
    /**
 
5856
     *
 
5857
     */
 
5858
    virtual double getX()
 
5859
        { return x; }
 
5860
 
 
5861
    /**
 
5862
     *
 
5863
     */
 
5864
    virtual void setX(double val) throw (DOMException)
 
5865
        { x = val; }
 
5866
 
 
5867
    /**
 
5868
     *
 
5869
     */
 
5870
    virtual double getY()
 
5871
        { return y; }
 
5872
 
 
5873
    /**
 
5874
     *
 
5875
     */
 
5876
    virtual void setY(double val) throw (DOMException)
 
5877
        { y = val; }
 
5878
 
 
5879
 
 
5880
 
 
5881
    //##################
 
5882
    //# Non-API methods
 
5883
    //##################
 
5884
 
 
5885
    /**
 
5886
     *
 
5887
     */
 
5888
    SVGPathSegCurvetoQuadraticSmoothAbs()
 
5889
        {
 
5890
        type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
 
5891
        x = y = 0.0;
 
5892
        }
 
5893
 
 
5894
 
 
5895
    /**
 
5896
     *
 
5897
     */
 
5898
    SVGPathSegCurvetoQuadraticSmoothAbs(double xArg, double yArg)
 
5899
        {
 
5900
        type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
 
5901
        x = xArg;     y = yArg;
 
5902
        }
 
5903
 
 
5904
    /**
 
5905
     *
 
5906
     */
 
5907
    SVGPathSegCurvetoQuadraticSmoothAbs(const SVGPathSegCurvetoQuadraticSmoothAbs &other)
 
5908
                     : SVGPathSeg(other)
 
5909
        {
 
5910
        type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;
 
5911
        x = y = 0.0;
 
5912
        }
 
5913
 
 
5914
    /**
 
5915
     *
 
5916
     */
 
5917
    virtual ~SVGPathSegCurvetoQuadraticSmoothAbs() {}
 
5918
 
 
5919
protected:
 
5920
 
 
5921
    double x, y;
 
5922
 
 
5923
};
 
5924
 
 
5925
 
 
5926
 
 
5927
 
 
5928
 
 
5929
 
 
5930
/*#########################################################################
 
5931
## SVGPathSegCurvetoQuadraticSmoothRel
 
5932
#########################################################################*/
 
5933
 
 
5934
/**
 
5935
 *
 
5936
 */
 
5937
class SVGPathSegCurvetoQuadraticSmoothRel : public SVGPathSeg
 
5938
{
 
5939
public:
 
5940
 
 
5941
    /**
 
5942
     *
 
5943
     */
 
5944
    virtual double getX()
 
5945
        { return x; }
 
5946
 
 
5947
    /**
 
5948
     *
 
5949
     */
 
5950
    virtual void setX(double val) throw (DOMException)
 
5951
        { x = val; }
 
5952
 
 
5953
    /**
 
5954
     *
 
5955
     */
 
5956
    virtual double getY()
 
5957
        { return y; }
 
5958
 
 
5959
    /**
 
5960
     *
 
5961
     */
 
5962
    virtual void setY(double val) throw (DOMException)
 
5963
        { y = val; }
 
5964
 
 
5965
 
 
5966
 
 
5967
    //##################
 
5968
    //# Non-API methods
 
5969
    //##################
 
5970
 
 
5971
    /**
 
5972
     *
 
5973
     */
 
5974
    SVGPathSegCurvetoQuadraticSmoothRel()
 
5975
        {
 
5976
        type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
 
5977
        x = y = 0.0;
 
5978
        }
 
5979
 
 
5980
 
 
5981
    /**
 
5982
     *
 
5983
     */
 
5984
    SVGPathSegCurvetoQuadraticSmoothRel(double xArg, double yArg)
 
5985
        {
 
5986
        type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
 
5987
        x = xArg;     y = yArg;
 
5988
        }
 
5989
 
 
5990
    /**
 
5991
     *
 
5992
     */
 
5993
    SVGPathSegCurvetoQuadraticSmoothRel(const SVGPathSegCurvetoQuadraticSmoothRel &other)
 
5994
                     : SVGPathSeg(other)
 
5995
        {
 
5996
        type = PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;
 
5997
        x = y = 0.0;
 
5998
        }
 
5999
 
 
6000
    /**
 
6001
     *
 
6002
     */
 
6003
    virtual ~SVGPathSegCurvetoQuadraticSmoothRel() {}
 
6004
 
 
6005
protected:
 
6006
 
 
6007
    double x, y;
 
6008
 
 
6009
};
 
6010
 
 
6011
 
 
6012
 
 
6013
 
 
6014
 
 
6015
 
 
6016
/*#########################################################################
 
6017
## SVGPathSegList
 
6018
#########################################################################*/
 
6019
 
 
6020
/**
 
6021
 *
 
6022
 */
 
6023
class SVGPathSegList
 
6024
{
 
6025
public:
 
6026
 
 
6027
    /**
 
6028
     *
 
6029
     */
 
6030
    virtual unsigned long getNumberOfItems()
 
6031
        { return items.size(); }
 
6032
 
 
6033
 
 
6034
    /**
 
6035
     *
 
6036
     */
 
6037
    virtual void clear () throw( DOMException )
 
6038
        { items.clear(); }
 
6039
 
 
6040
    /**
 
6041
     *
 
6042
     */
 
6043
    virtual SVGPathSeg initialize (const SVGPathSeg &newItem)
 
6044
                    throw( DOMException, SVGException )
 
6045
        {
 
6046
        items.clear();
 
6047
        items.push_back(newItem);
 
6048
        return newItem;
 
6049
        }
 
6050
 
 
6051
    /**
 
6052
     *
 
6053
     */
 
6054
    virtual SVGPathSeg getItem (unsigned long index)
 
6055
                    throw( DOMException )
 
6056
        {
 
6057
        if (index >= items.size())
 
6058
            {
 
6059
            SVGPathSeg seg;
 
6060
            return seg;
 
6061
            }
 
6062
        return items[index];
 
6063
        }
 
6064
 
 
6065
    /**
 
6066
     *
 
6067
     */
 
6068
    virtual SVGPathSeg insertItemBefore(const SVGPathSeg &newItem,
 
6069
                                        unsigned long index )
 
6070
                          throw( DOMException, SVGException )
 
6071
        {
 
6072
        if (index >= items.size())
 
6073
            items.push_back(newItem);
 
6074
        else
 
6075
            {
 
6076
            std::vector<SVGPathSeg>::iterator iter = items.begin() + index;
 
6077
            items.insert(iter, newItem);
 
6078
            }
 
6079
        return newItem;
 
6080
        }
 
6081
 
 
6082
    /**
 
6083
     *
 
6084
     */
 
6085
    virtual SVGPathSeg replaceItem(const SVGPathSeg &newItem,
 
6086
                                   unsigned long index )
 
6087
                              throw( DOMException, SVGException )
 
6088
        {
 
6089
        if (index >= items.size())
 
6090
            {
 
6091
            SVGPathSeg seg;
 
6092
            return seg;
 
6093
            }
 
6094
        std::vector<SVGPathSeg>::iterator iter = items.begin() + index;
 
6095
        *iter = newItem;
 
6096
        return newItem;
 
6097
        }
 
6098
 
 
6099
    /**
 
6100
     *
 
6101
     */
 
6102
    virtual SVGPathSeg removeItem (unsigned long index)
 
6103
                                  throw (DOMException)
 
6104
        {
 
6105
        if (index >= items.size())
 
6106
            {
 
6107
            SVGPathSeg seg;
 
6108
            return seg;
 
6109
            }
 
6110
        std::vector<SVGPathSeg>::iterator iter = items.begin() + index;
 
6111
        SVGPathSeg olditem = *iter;
 
6112
        items.erase(iter);
 
6113
        return olditem;
 
6114
        }
 
6115
 
 
6116
    /**
 
6117
     *
 
6118
     */
 
6119
    virtual SVGPathSeg appendItem (const SVGPathSeg &newItem)
 
6120
                    throw( DOMException, SVGException )
 
6121
        {
 
6122
        items.push_back(newItem);
 
6123
        return newItem;
 
6124
        }
 
6125
 
 
6126
 
 
6127
 
 
6128
    //##################
 
6129
    //# Non-API methods
 
6130
    //##################
 
6131
 
 
6132
    /**
 
6133
     *
 
6134
     */
 
6135
    SVGPathSegList() {}
 
6136
 
 
6137
 
 
6138
    /**
 
6139
     *
 
6140
     */
 
6141
    SVGPathSegList(const SVGPathSegList &other)
 
6142
        {
 
6143
        items = other.items;
 
6144
        }
 
6145
 
 
6146
 
 
6147
    /**
 
6148
     *
 
6149
     */
 
6150
    virtual ~SVGPathSegList() {}
 
6151
 
 
6152
protected:
 
6153
 
 
6154
    std::vector<SVGPathSeg> items;
 
6155
 
 
6156
};
 
6157
 
 
6158
 
 
6159
 
 
6160
 
 
6161
 
 
6162
 
 
6163
/*#########################################################################
 
6164
## SVGAnimatedPathData
 
6165
#########################################################################*/
 
6166
 
 
6167
/**
 
6168
 *
 
6169
 */
 
6170
class SVGAnimatedPathData
 
6171
{
 
6172
public:
 
6173
 
 
6174
    /**
 
6175
     *
 
6176
     */
 
6177
    virtual SVGPathSegList getPathSegList()
 
6178
        {
 
6179
        SVGPathSegList list;
 
6180
        return list;
 
6181
        }
 
6182
 
 
6183
    /**
 
6184
     *
 
6185
     */
 
6186
    virtual SVGPathSegList getNormalizedPathSegList()
 
6187
        {
 
6188
        SVGPathSegList list;
 
6189
        return list;
 
6190
        }
 
6191
 
 
6192
    /**
 
6193
     *
 
6194
     */
 
6195
    virtual SVGPathSegList getAnimatedPathSegList()
 
6196
        {
 
6197
        SVGPathSegList list;
 
6198
        return list;
 
6199
        }
 
6200
 
 
6201
    /**
 
6202
     *
 
6203
     */
 
6204
    virtual SVGPathSegList getAnimatedNormalizedPathSegList()
 
6205
        {
 
6206
        SVGPathSegList list;
 
6207
        return list;
 
6208
        }
 
6209
 
 
6210
 
 
6211
 
 
6212
    //##################
 
6213
    //# Non-API methods
 
6214
    //##################
 
6215
 
 
6216
    /**
 
6217
     *
 
6218
     */
 
6219
   SVGAnimatedPathData()
 
6220
        {}
 
6221
 
 
6222
    /**
 
6223
     *
 
6224
     */
 
6225
   SVGAnimatedPathData(const SVGAnimatedPathData &/*other*/)
 
6226
        {
 
6227
        }
 
6228
 
 
6229
    /**
 
6230
     *
 
6231
     */
 
6232
    virtual ~SVGAnimatedPathData() {}
 
6233
 
 
6234
};
 
6235
 
 
6236
 
 
6237
 
 
6238
 
 
6239
 
 
6240
 
 
6241
/*#########################################################################
 
6242
## SVGAnimatedPoints
 
6243
#########################################################################*/
 
6244
 
 
6245
/**
 
6246
 *
 
6247
 */
 
6248
class SVGAnimatedPoints
 
6249
{
 
6250
public:
 
6251
 
 
6252
    /**
 
6253
     *
 
6254
     */
 
6255
    virtual SVGPointList getPoints()
 
6256
        { return points; }
 
6257
 
 
6258
    /**
 
6259
     *
 
6260
     */
 
6261
    virtual SVGPointList getAnimatedPoints()
 
6262
        { return animatedPoints; }
 
6263
 
 
6264
 
 
6265
 
 
6266
    //##################
 
6267
    //# Non-API methods
 
6268
    //##################
 
6269
 
 
6270
    /**
 
6271
     *
 
6272
     */
 
6273
    SVGAnimatedPoints() {}
 
6274
 
 
6275
    /**
 
6276
     *
 
6277
     */
 
6278
    SVGAnimatedPoints(const SVGAnimatedPoints &other)
 
6279
        {
 
6280
        points         = other.points;
 
6281
        animatedPoints = other.animatedPoints;
 
6282
        }
 
6283
 
 
6284
    /**
 
6285
     *
 
6286
     */
 
6287
    virtual ~SVGAnimatedPoints() {}
 
6288
 
 
6289
protected:
 
6290
 
 
6291
    SVGPointList points;
 
6292
    SVGPointList animatedPoints;
 
6293
 
 
6294
};
 
6295
 
 
6296
 
 
6297
 
 
6298
 
 
6299
 
 
6300
/*#########################################################################
 
6301
## SVGPaint
 
6302
#########################################################################*/
 
6303
 
 
6304
/**
 
6305
 *
 
6306
 */
 
6307
class SVGPaint : public SVGColor
 
6308
{
 
6309
public:
 
6310
 
 
6311
 
 
6312
    /**
 
6313
     * Paint Types
 
6314
     */
 
6315
    typedef enum
 
6316
        {
 
6317
        SVG_PAINTTYPE_UNKNOWN               = 0,
 
6318
        SVG_PAINTTYPE_RGBCOLOR              = 1,
 
6319
        SVG_PAINTTYPE_RGBCOLOR_ICCCOLOR     = 2,
 
6320
        SVG_PAINTTYPE_NONE                  = 101,
 
6321
        SVG_PAINTTYPE_CURRENTCOLOR          = 102,
 
6322
        SVG_PAINTTYPE_URI_NONE              = 103,
 
6323
        SVG_PAINTTYPE_URI_CURRENTCOLOR      = 104,
 
6324
        SVG_PAINTTYPE_URI_RGBCOLOR          = 105,
 
6325
        SVG_PAINTTYPE_URI_RGBCOLOR_ICCCOLOR = 106,
 
6326
        SVG_PAINTTYPE_URI                   = 107
 
6327
        } PaintType;
 
6328
 
 
6329
 
 
6330
    /**
 
6331
     *
 
6332
     */
 
6333
    virtual unsigned short getPaintType()
 
6334
        { return paintType; }
 
6335
 
 
6336
    /**
 
6337
     *
 
6338
     */
 
6339
    virtual DOMString getUri()
 
6340
        { return uri; }
 
6341
 
 
6342
    /**
 
6343
     *
 
6344
     */
 
6345
    virtual void setUri (const DOMString& uriArg )
 
6346
        { uri = uriArg; }
 
6347
 
 
6348
    /**
 
6349
     *
 
6350
     */
 
6351
    virtual void setPaint (unsigned short paintTypeArg,
 
6352
                           const DOMString& uriArg,
 
6353
                           const DOMString& /*rgbColor*/,
 
6354
                           const DOMString& /*iccColor*/ )
 
6355
                           throw( SVGException )
 
6356
        {
 
6357
        paintType = paintTypeArg;
 
6358
        uri       = uriArg;
 
6359
        //do something with rgbColor
 
6360
        //do something with iccColor;
 
6361
        }
 
6362
 
 
6363
 
 
6364
 
 
6365
    //##################
 
6366
    //# Non-API methods
 
6367
    //##################
 
6368
 
 
6369
    /**
 
6370
     *
 
6371
     */
 
6372
    SVGPaint()
 
6373
        {
 
6374
        uri       = "";
 
6375
        paintType = SVG_PAINTTYPE_UNKNOWN;
 
6376
        }
 
6377
 
 
6378
    /**
 
6379
     *
 
6380
     */
 
6381
    SVGPaint(const SVGPaint &other) : css::CSSValue(other), SVGColor(other)
 
6382
        {
 
6383
        uri       = "";
 
6384
        paintType = SVG_PAINTTYPE_UNKNOWN;
 
6385
        }
 
6386
 
 
6387
    /**
 
6388
     *
 
6389
     */
 
6390
    virtual ~SVGPaint() {}
 
6391
 
 
6392
protected:
 
6393
 
 
6394
    unsigned int paintType;
 
6395
    DOMString uri;
 
6396
 
 
6397
};
 
6398
 
 
6399
 
 
6400
 
 
6401
 
 
6402
/*#########################################################################
 
6403
## SVGColorProfileRule
 
6404
#########################################################################*/
 
6405
 
 
6406
/**
 
6407
 *
 
6408
 */
 
6409
class SVGColorProfileRule : public SVGCSSRule,
 
6410
                            public SVGRenderingIntent
 
6411
{
 
6412
 
 
6413
public:
 
6414
   /**
 
6415
     *
 
6416
     */
 
6417
    virtual DOMString getSrc()
 
6418
        { return src; }
 
6419
 
 
6420
    /**
 
6421
     *
 
6422
     */
 
6423
    virtual void setSrc(const DOMString &val) throw (DOMException)
 
6424
        { src = val; }
 
6425
 
 
6426
    /**
 
6427
     *
 
6428
     */
 
6429
    virtual DOMString getName()
 
6430
        { return name; }
 
6431
 
 
6432
    /**
 
6433
     *
 
6434
     */
 
6435
    virtual void setName(const DOMString &val) throw (DOMException)
 
6436
        { name = val; }
 
6437
 
 
6438
    /**
 
6439
     *
 
6440
     */
 
6441
    virtual unsigned short getRenderingIntent()
 
6442
        { return renderingIntent; }
 
6443
 
 
6444
    /**
 
6445
     *
 
6446
     */
 
6447
    virtual void setRenderingIntent(unsigned short val) throw (DOMException)
 
6448
        { renderingIntent = val; }
 
6449
 
 
6450
 
 
6451
    //##################
 
6452
    //# Non-API methods
 
6453
    //##################
 
6454
 
 
6455
    /**
 
6456
     *
 
6457
     */
 
6458
    SVGColorProfileRule() {}
 
6459
 
 
6460
    /**
 
6461
     *
 
6462
     */
 
6463
    SVGColorProfileRule(const SVGColorProfileRule &other)
 
6464
               : SVGCSSRule(other), SVGRenderingIntent(other)
 
6465
        {
 
6466
        renderingIntent = other.renderingIntent;
 
6467
        src             = other.src;
 
6468
        name            = other.name;
 
6469
        }
 
6470
 
 
6471
    /**
 
6472
     *
 
6473
     */
 
6474
    virtual ~SVGColorProfileRule() {}
 
6475
 
 
6476
protected:
 
6477
 
 
6478
    unsigned short renderingIntent;
 
6479
    DOMString src;
 
6480
    DOMString name;
 
6481
 
 
6482
};
 
6483
 
 
6484
 
 
6485
 
 
6486
/*#########################################################################
 
6487
## SVGFilterPrimitiveStandardAttributes
 
6488
#########################################################################*/
 
6489
 
 
6490
/**
 
6491
 *
 
6492
 */
 
6493
class SVGFilterPrimitiveStandardAttributes : public SVGStylable
 
6494
{
 
6495
public:
 
6496
 
 
6497
 
 
6498
 
 
6499
    /**
 
6500
     *
 
6501
     */
 
6502
    virtual SVGAnimatedLength getX()
 
6503
        { return x; }
 
6504
 
 
6505
    /**
 
6506
     *
 
6507
     */
 
6508
    virtual SVGAnimatedLength getY()
 
6509
        { return y; }
 
6510
 
 
6511
    /**
 
6512
     *
 
6513
     */
 
6514
    virtual SVGAnimatedLength getWidth()
 
6515
        { return width; }
 
6516
 
 
6517
    /**
 
6518
     *
 
6519
     */
 
6520
    virtual SVGAnimatedLength getHeight()
 
6521
        { return height; }
 
6522
 
 
6523
    /**
 
6524
     *
 
6525
     */
 
6526
    virtual SVGAnimatedString getResult()
 
6527
        { return result; }
 
6528
 
 
6529
 
 
6530
 
 
6531
    //##################
 
6532
    //# Non-API methods
 
6533
    //##################
 
6534
 
 
6535
 
 
6536
    /**
 
6537
     *
 
6538
     */
 
6539
    SVGFilterPrimitiveStandardAttributes()
 
6540
        {}
 
6541
 
 
6542
    /**
 
6543
     *
 
6544
     */
 
6545
    SVGFilterPrimitiveStandardAttributes(const SVGFilterPrimitiveStandardAttributes &other)
 
6546
                                 : SVGStylable(other)
 
6547
        {
 
6548
        x      = other.x;
 
6549
        y      = other.y;
 
6550
        width  = other.width;
 
6551
        height = other.height;
 
6552
        result = other.result;
 
6553
        }
 
6554
 
 
6555
    /**
 
6556
     *
 
6557
     */
 
6558
    virtual ~SVGFilterPrimitiveStandardAttributes() {}
 
6559
 
 
6560
protected:
 
6561
 
 
6562
    SVGAnimatedLength x;
 
6563
    SVGAnimatedLength y;
 
6564
    SVGAnimatedLength width;
 
6565
    SVGAnimatedLength height;
 
6566
    SVGAnimatedString result;
 
6567
 
 
6568
};
 
6569
 
 
6570
 
 
6571
 
 
6572
 
 
6573
 
 
6574
 
 
6575
 
 
6576
 
 
6577
 
 
6578
 
 
6579
 
 
6580
/*#########################################################################
 
6581
## SVGEvent
 
6582
#########################################################################*/
 
6583
 
 
6584
/**
 
6585
 *
 
6586
 */
 
6587
class SVGEvent : events::Event
 
6588
{
 
6589
public:
 
6590
 
 
6591
    //##################
 
6592
    //# Non-API methods
 
6593
    //##################
 
6594
 
 
6595
    /**
 
6596
     *
 
6597
     */
 
6598
    SVGEvent() {}
 
6599
 
 
6600
    /**
 
6601
     *
 
6602
     */
 
6603
    SVGEvent(const SVGEvent &other) : events::Event(other)
 
6604
        {}
 
6605
 
 
6606
    /**
 
6607
     *
 
6608
     */
 
6609
    virtual ~SVGEvent() {}
 
6610
 
 
6611
};
 
6612
 
 
6613
 
 
6614
 
 
6615
 
 
6616
/*#########################################################################
 
6617
## SVGZoomEvent
 
6618
#########################################################################*/
 
6619
 
 
6620
/**
 
6621
 *
 
6622
 */
 
6623
class SVGZoomEvent : events::UIEvent
 
6624
{
 
6625
public:
 
6626
 
 
6627
    /**
 
6628
     *
 
6629
     */
 
6630
    virtual SVGRect getZoomRectScreen()
 
6631
        { return zoomRectScreen; }
 
6632
 
 
6633
    /**
 
6634
     *
 
6635
     */
 
6636
    virtual double getPreviousScale()
 
6637
        { return previousScale; }
 
6638
 
 
6639
    /**
 
6640
     *
 
6641
     */
 
6642
    virtual SVGPoint getPreviousTranslate()
 
6643
        { return previousTranslate; }
 
6644
 
 
6645
    /**
 
6646
     *
 
6647
     */
 
6648
    virtual double getNewScale()
 
6649
        { return newScale; }
 
6650
 
 
6651
   /**
 
6652
     *
 
6653
     */
 
6654
    virtual SVGPoint getNewTranslate()
 
6655
        { return newTranslate; }
 
6656
 
 
6657
 
 
6658
 
 
6659
    //##################
 
6660
    //# Non-API methods
 
6661
    //##################
 
6662
 
 
6663
    /**
 
6664
     *
 
6665
     */
 
6666
    SVGZoomEvent()
 
6667
        {}
 
6668
 
 
6669
    /**
 
6670
     *
 
6671
     */
 
6672
    SVGZoomEvent(const SVGZoomEvent &other) : events::Event(other),
 
6673
                                              events::UIEvent(other)
 
6674
        {
 
6675
        zoomRectScreen    = other.zoomRectScreen;
 
6676
        previousScale     = other.previousScale;
 
6677
        previousTranslate = other.previousTranslate;
 
6678
        newScale          = other.newScale;
 
6679
        newTranslate      = other.newTranslate;
 
6680
        }
 
6681
 
 
6682
    /**
 
6683
     *
 
6684
     */
 
6685
    virtual ~SVGZoomEvent() {}
 
6686
 
 
6687
protected:
 
6688
 
 
6689
    SVGRect  zoomRectScreen;
 
6690
    double   previousScale;
 
6691
    SVGPoint previousTranslate;
 
6692
    double   newScale;
 
6693
    SVGPoint newTranslate;
 
6694
 
 
6695
};
 
6696
 
 
6697
 
 
6698
 
 
6699
/*#########################################################################
 
6700
## SVGElementInstance
 
6701
#########################################################################*/
 
6702
 
 
6703
/**
 
6704
 *
 
6705
 */
 
6706
class SVGElementInstance : public events::EventTarget
 
6707
{
 
6708
public:
 
6709
 
 
6710
    /**
 
6711
     *
 
6712
     */
 
6713
    virtual SVGElementPtr getCorrespondingElement()
 
6714
        { return correspondingElement; }
 
6715
 
 
6716
    /**
 
6717
     *
 
6718
     */
 
6719
    virtual SVGUseElementPtr getCorrespondingUseElement()
 
6720
        { return correspondingUseElement; }
 
6721
 
 
6722
    /**
 
6723
     *
 
6724
     */
 
6725
    virtual SVGElementInstance getParentNode()
 
6726
        {
 
6727
        SVGElementInstance ret;
 
6728
        return ret;
 
6729
        }
 
6730
 
 
6731
    /**
 
6732
     *  Since we are using stack types and this is a circular definition,
 
6733
     *  we will instead implement this as a global function below:
 
6734
     *   SVGElementInstanceList getChildNodes(const SVGElementInstance instance);
 
6735
     */
 
6736
    //virtual SVGElementInstanceList getChildNodes();
 
6737
 
 
6738
    /**
 
6739
     *
 
6740
     */
 
6741
    virtual SVGElementInstance getFirstChild()
 
6742
        {
 
6743
        SVGElementInstance ret;
 
6744
        return ret;
 
6745
        }
 
6746
 
 
6747
    /**
 
6748
     *
 
6749
     */
 
6750
    virtual SVGElementInstance getLastChild()
 
6751
        {
 
6752
        SVGElementInstance ret;
 
6753
        return ret;
 
6754
        }
 
6755
 
 
6756
    /**
 
6757
     *
 
6758
     */
 
6759
    virtual SVGElementInstance getPreviousSibling()
 
6760
        {
 
6761
        SVGElementInstance ret;
 
6762
        return ret;
 
6763
        }
 
6764
 
 
6765
    /**
 
6766
     *
 
6767
     */
 
6768
    virtual SVGElementInstance getNextSibling()
 
6769
        {
 
6770
        SVGElementInstance ret;
 
6771
        return ret;
 
6772
        }
 
6773
 
 
6774
 
 
6775
    //##################
 
6776
    //# Non-API methods
 
6777
    //##################
 
6778
 
 
6779
    /**
 
6780
     *
 
6781
     */
 
6782
    SVGElementInstance() {}
 
6783
 
 
6784
    /**
 
6785
     *
 
6786
     */
 
6787
    SVGElementInstance(const SVGElementInstance &other)
 
6788
                        : events::EventTarget(other)
 
6789
        {
 
6790
        }
 
6791
 
 
6792
    /**
 
6793
     *
 
6794
     */
 
6795
    virtual ~SVGElementInstance() {}
 
6796
 
 
6797
protected:
 
6798
 
 
6799
    SVGElementPtr      correspondingElement;
 
6800
    SVGUseElementPtr   correspondingUseElement;
 
6801
 
 
6802
};
 
6803
 
 
6804
 
 
6805
 
 
6806
 
 
6807
 
 
6808
 
 
6809
/*#########################################################################
 
6810
## SVGElementInstanceList
 
6811
#########################################################################*/
 
6812
 
 
6813
/**
 
6814
 *
 
6815
 */
 
6816
class SVGElementInstanceList
 
6817
{
 
6818
public:
 
6819
 
 
6820
 
 
6821
    /**
 
6822
     *
 
6823
     */
 
6824
    virtual unsigned long getLength()
 
6825
        { return items.size(); }
 
6826
 
 
6827
    /**
 
6828
     *
 
6829
     */
 
6830
    virtual SVGElementInstance item (unsigned long index )
 
6831
        {
 
6832
        if (index >= items.size())
 
6833
            {
 
6834
            SVGElementInstance ret;
 
6835
            return ret;
 
6836
            }
 
6837
        return items[index];
 
6838
        }
 
6839
 
 
6840
    /**
 
6841
     *  This static method replaces the circular definition of:
 
6842
     *        SVGElementInstanceList SVGElementInstance::getChildNodes()
 
6843
     *
 
6844
     */
 
6845
    static SVGElementInstanceList getChildNodes(const SVGElementInstance &/*instance*/)
 
6846
        {
 
6847
        SVGElementInstanceList list;
 
6848
        return list;
 
6849
        }
 
6850
 
 
6851
 
 
6852
    //##################
 
6853
    //# Non-API methods
 
6854
    //##################
 
6855
 
 
6856
    /**
 
6857
     *
 
6858
     */
 
6859
    SVGElementInstanceList() {}
 
6860
 
 
6861
    /**
 
6862
     *
 
6863
     */
 
6864
    SVGElementInstanceList(const SVGElementInstanceList &other)
 
6865
        {
 
6866
        items = other.items;
 
6867
        }
 
6868
 
 
6869
    /**
 
6870
     *
 
6871
     */
 
6872
    virtual ~SVGElementInstanceList() {}
 
6873
 
 
6874
protected:
 
6875
 
 
6876
    std::vector<SVGElementInstance> items;
 
6877
 
 
6878
 
 
6879
};
 
6880
 
 
6881
 
 
6882
 
 
6883
 
 
6884
 
 
6885
 
 
6886
 
 
6887
 
 
6888
 
 
6889
 
 
6890
 
 
6891
 
 
6892
 
 
6893
}  //namespace svg
 
6894
}  //namespace dom
 
6895
}  //namespace w3c
 
6896
}  //namespace org
 
6897
 
 
6898
#endif /* __SVGTYPES_H__ */
 
6899
/*#########################################################################
 
6900
## E N D    O F    F I L E
 
6901
#########################################################################*/
 
6902