← Back to branch summary

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

« back to all changes in this revision

Viewing changes to inkscape-0.47pre1/src/extension/internal/odf.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/extension/internal/odf.h
 
1
/**
 
2
 * OpenDocument <drawing> input and output
 
3
 *
 
4
 * This is an an entry in the extensions mechanism to begin to enable
 
5
 * the inputting and outputting of OpenDocument Format (ODF) files from
 
6
 * within Inkscape.  Although the initial implementations will be very lossy
 
7
 * do to the differences in the models of SVG and ODF, they will hopefully
 
8
 * improve greatly with time.
 
9
 *
 
10
 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
 
11
 *
 
12
 * Authors:
 
13
 *   Bob Jamison
 
14
 *
 
15
 * Copyright (C) 2006 Bob Jamison
 
16
 *
 
17
 *  This library is free software; you can redistribute it and/or
 
18
 *  modify it under the terms of the GNU Lesser General Public
 
19
 *  License as published by the Free Software Foundation; either
 
20
 *  version 2.1 of the License, or (at your option) any later version.
 
21
 *
 
22
 *  This library is distributed in the hope that it will be useful,
 
23
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
24
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
25
 *  Lesser General Public License for more details.
 
26
 *
 
27
 *  You should have received a copy of the GNU Lesser General Public
 
28
 *  License along with this library; if not, write to the Free Software
 
29
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
30
 */
 
31
 
 
32
#ifndef EXTENSION_INTERNAL_ODG_OUT_H
 
33
#define EXTENSION_INTERNAL_ODG_OUT_H
 
34
 
 
35
#include <dom/dom.h>
 
36
#include <dom/io/stringstream.h>
 
37
#include <dom/uri.h>
 
38
 
 
39
#include <glibmm.h>
 
40
#include "extension/implementation/implementation.h"
 
41
 
 
42
 
 
43
#include <xml/repr.h>
 
44
 
 
45
#include <string>
 
46
#include <map>
 
47
 
 
48
#include <dom/util/ziptool.h>
 
49
#include <dom/io/domstream.h>
 
50
 
 
51
 
 
52
namespace Inkscape
 
53
{
 
54
namespace Extension
 
55
{
 
56
namespace Internal
 
57
{
 
58
 
 
59
typedef org::w3c::dom::URI URI;
 
60
typedef org::w3c::dom::io::Writer Writer;
 
61
 
 
62
 
 
63
class StyleInfo
 
64
{
 
65
public:
 
66
 
 
67
    StyleInfo()
 
68
        {
 
69
        init();
 
70
        }
 
71
 
 
72
    StyleInfo(const StyleInfo &other)
 
73
        {
 
74
        assign(other);
 
75
        }
 
76
 
 
77
    StyleInfo &operator=(const StyleInfo &other)
 
78
        {
 
79
        assign(other);
 
80
        return *this;
 
81
        }
 
82
 
 
83
    void assign(const StyleInfo &other)
 
84
        {
 
85
        name          = other.name;
 
86
        stroke        = other.stroke;
 
87
        strokeColor   = other.strokeColor;
 
88
        strokeWidth   = other.strokeWidth;
 
89
        strokeOpacity = other.strokeOpacity;
 
90
        fill          = other.fill;
 
91
        fillColor     = other.fillColor;
 
92
        fillOpacity   = other.fillOpacity;
 
93
        }
 
94
 
 
95
    void init()
 
96
        {
 
97
        name          = "none";
 
98
        stroke        = "none";
 
99
        strokeColor   = "none";
 
100
        strokeWidth   = "none";
 
101
        strokeOpacity = "none";
 
102
        fill          = "none";
 
103
        fillColor     = "none";
 
104
        fillOpacity   = "none";
 
105
        }
 
106
 
 
107
    virtual ~StyleInfo()
 
108
        {}
 
109
 
 
110
    //used for eliminating duplicates in the styleTable
 
111
    bool equals(const StyleInfo &other)
 
112
        {
 
113
        if (
 
114
            stroke        != other.stroke        ||
 
115
            strokeColor   != other.strokeColor   ||
 
116
            strokeWidth   != other.strokeWidth   ||
 
117
            strokeOpacity != other.strokeOpacity ||
 
118
            fill          != other.fill          ||
 
119
            fillColor     != other.fillColor     ||
 
120
            fillOpacity   != other.fillOpacity
 
121
           )
 
122
            return false;
 
123
        return true;
 
124
        }
 
125
 
 
126
    Glib::ustring name;
 
127
    Glib::ustring stroke;
 
128
    Glib::ustring strokeColor;
 
129
    Glib::ustring strokeWidth;
 
130
    Glib::ustring strokeOpacity;
 
131
    Glib::ustring fill;
 
132
    Glib::ustring fillColor;
 
133
    Glib::ustring fillOpacity;
 
134
 
 
135
};
 
136
 
 
137
 
 
138
 
 
139
 
 
140
class GradientStop
 
141
{
 
142
public:
 
143
    GradientStop()
 
144
        {}
 
145
    GradientStop(unsigned long rgbArg, double opacityArg)
 
146
        { rgb = rgbArg; opacity = opacityArg; }
 
147
    virtual ~GradientStop()
 
148
        {}
 
149
    GradientStop(const GradientStop &other)
 
150
        {  assign(other); }
 
151
    virtual GradientStop operator=(const GradientStop &other)
 
152
        {  assign(other); return *this; }
 
153
    void assign(const GradientStop &other)
 
154
        {
 
155
        rgb = other.rgb;
 
156
        opacity = other.opacity;
 
157
        }
 
158
    unsigned long rgb;
 
159
    double opacity;
 
160
};
 
161
 
 
162
 
 
163
 
 
164
class GradientInfo
 
165
{
 
166
public:
 
167
 
 
168
    GradientInfo()
 
169
        {
 
170
        init();
 
171
        }
 
172
 
 
173
    GradientInfo(const GradientInfo &other)
 
174
        {
 
175
        assign(other);
 
176
        }
 
177
 
 
178
    GradientInfo &operator=(const GradientInfo &other)
 
179
        {
 
180
        assign(other);
 
181
        return *this;
 
182
        }
 
183
 
 
184
    void assign(const GradientInfo &other)
 
185
        {
 
186
        name          = other.name;
 
187
        style         = other.style;
 
188
        cx            = other.cx;
 
189
        cy            = other.cy;
 
190
        fx            = other.fx;
 
191
        fy            = other.fy;
 
192
        r             = other.r;
 
193
        x1            = other.x1;
 
194
        y1            = other.y1;
 
195
        x2            = other.x2;
 
196
        y2            = other.y2;
 
197
        stops         = other.stops;
 
198
        }
 
199
 
 
200
    void init()
 
201
        {
 
202
        name          = "none";
 
203
        style         = "none";
 
204
        cx            = 0.0;
 
205
        cy            = 0.0;
 
206
        fx            = 0.0;
 
207
        fy            = 0.0;
 
208
        r             = 0.0;
 
209
        x1            = 0.0;
 
210
        y1            = 0.0;
 
211
        x2            = 0.0;
 
212
        y2            = 0.0;
 
213
        stops.clear();
 
214
        }
 
215
 
 
216
    virtual ~GradientInfo()
 
217
        {}
 
218
 
 
219
    //used for eliminating duplicates in the styleTable
 
220
    bool equals(const GradientInfo &other)
 
221
        {
 
222
        if (
 
223
            name        != other.name   ||
 
224
            style       != other.style  ||
 
225
            cx          != other.cx     ||
 
226
            cy          != other.cy     ||
 
227
            fx          != other.fx     ||
 
228
            fy          != other.fy     ||
 
229
            r           != other.r      ||
 
230
            x1          != other.x1     ||
 
231
            y1          != other.y1     ||
 
232
            x2          != other.x2     ||
 
233
            y2          != other.y2
 
234
           )
 
235
            return false;
 
236
        if (stops.size() != other.stops.size())
 
237
            return false;
 
238
        for (unsigned int i=0 ; i<stops.size() ; i++)
 
239
            {
 
240
            GradientStop g1 = stops[i];
 
241
            GradientStop g2 = other.stops[i];
 
242
            if (g1.rgb != g2.rgb)
 
243
                return false;
 
244
            if (g1.opacity != g2.opacity)
 
245
                return false;
 
246
            }
 
247
        return true;
 
248
        }
 
249
 
 
250
    Glib::ustring name;
 
251
    Glib::ustring style;
 
252
    double cx;
 
253
    double cy;
 
254
    double fx;
 
255
    double fy;
 
256
    double r;
 
257
    double x1;
 
258
    double y1;
 
259
    double x2;
 
260
    double y2;
 
261
    std::vector<GradientStop> stops;
 
262
 
 
263
};
 
264
 
 
265
 
 
266
 
 
267
class OdfOutput : public Inkscape::Extension::Implementation::Implementation
 
268
{
 
269
 
 
270
public:
 
271
 
 
272
    bool check (Inkscape::Extension::Extension * module);
 
273
 
 
274
    void save  (Inkscape::Extension::Output *mod,
 
275
                SPDocument *doc,
 
276
                gchar const *filename);
 
277
 
 
278
    static void   init  (void);
 
279
 
 
280
private:
 
281
 
 
282
    URI documentUri;
 
283
 
 
284
    void reset();
 
285
 
 
286
    //cc or dc metadata name/value pairs
 
287
    std::map<Glib::ustring, Glib::ustring> metadata;
 
288
 
 
289
    /* Style table
 
290
       Uses a two-stage lookup to avoid style duplication.
 
291
       Use like:
 
292
       StyleInfo si = styleTable[styleLookupTable[id]];
 
293
       but check for errors, of course
 
294
    */
 
295
    //element id -> style entry name
 
296
    std::map<Glib::ustring, Glib::ustring> styleLookupTable;
 
297
    //style entry name -> style info
 
298
    std::vector<StyleInfo> styleTable;
 
299
 
 
300
    //element id -> gradient entry name
 
301
    std::map<Glib::ustring, Glib::ustring> gradientLookupTable;
 
302
    //gradient entry name -> gradient info
 
303
    std::vector<GradientInfo> gradientTable;
 
304
 
 
305
    //for renaming image file names
 
306
    std::map<Glib::ustring, Glib::ustring> imageTable;
 
307
 
 
308
    void preprocess(ZipFile &zf, Inkscape::XML::Node *node);
 
309
 
 
310
    bool writeManifest(ZipFile &zf);
 
311
 
 
312
    bool writeMeta(ZipFile &zf);
 
313
 
 
314
    bool writeStyle(ZipFile &zf);
 
315
 
 
316
    bool processStyle(Writer &outs, SPItem *item, const Glib::ustring &id);
 
317
 
 
318
    bool processGradient(Writer &outs, SPItem *item,
 
319
                    const Glib::ustring &id, Geom::Matrix &tf);
 
320
 
 
321
    bool writeStyleHeader(Writer &outs);
 
322
 
 
323
    bool writeStyleFooter(Writer &outs);
 
324
 
 
325
    bool writeContentHeader(Writer &outs);
 
326
 
 
327
    bool writeContentFooter(Writer &outs);
 
328
 
 
329
    bool writeTree(Writer &couts, Writer &souts, Inkscape::XML::Node *node);
 
330
 
 
331
    bool writeContent(ZipFile &zf, Inkscape::XML::Node *node);
 
332
 
 
333
};
 
334
 
 
335
 
 
336
 
 
337
 
 
338
}  //namespace Internal
 
339
}  //namespace Extension
 
340
}  //namespace Inkscape
 
341
 
 
342
 
 
343
 
 
344
#endif /* EXTENSION_INTERNAL_ODG_OUT_H */
 
345