← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/koffice/oneiric-updates

« back to all changes in this revision

Viewing changes to filters/kspread/xlsx/XlsxXmlDrawingReader.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2010-10-27 17:52:57 UTC
  • mfrom: (0.12.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20101027175257-s04zqqk5bs8ckm9o
Tags: 1:2.2.83-0ubuntu1
* Merge with Debian git remaining changes:
 - Add build-deps on librcps-dev, opengtl-dev, libqtgtl-dev, freetds-dev,
   create-resources, libspnav-dev
 - Remove needless build-dep on libwv2-dev
 - koffice-libs recommends create-resources
 - krita recommends pstoedit
 - Keep our patches
* New upstream release 2.3 beta 3
  - Remove debian/patches fixed by upstream
  - Update install files

Show diffs side-by-side

added added

removed removed

Lines of Context:
filters/kspread/xlsx/XlsxXmlDrawingReader.cpp
24
24
 
25
25
#include "XlsxXmlDrawingReader.h"
26
26
#include "XlsxXmlWorksheetReader.h"
 
27
#include "XlsxXmlWorksheetReader_p.h"
27
28
#include "XlsxXmlChartReader.h"
28
29
#include "XlsxImport.h"
 
30
#include "Charting.h"
 
31
#include "ChartExport.h"
 
32
 
 
33
#include <MsooXmlSchemas.h>
 
34
#include <MsooXmlUtils.h>
 
35
#include <MsooXmlRelationships.h>
 
36
#include <MsooXmlUnits.h>
 
37
#include <MsooXmlDiagramReader.h>
 
38
 
 
39
#include <KoXmlWriter.h>
 
40
#include <KoGenStyles.h>
 
41
#include <KoOdfGraphicStyles.h>
 
42
#include <KoUnit.h>
 
43
#include <QFontMetricsF>
 
44
 
 
45
#include <kspread/Util.h>
29
46
 
30
47
#define MSOOXML_CURRENT_NS "xdr"
31
48
#define MSOOXML_CURRENT_CLASS XlsxXmlDrawingReader
33
50
 
34
51
#include <MsooXmlReader_p.h>
35
52
#include <MsooXmlUtils.h>
36
 
 
37
 
XlsxXmlDrawingReaderContext::XlsxXmlDrawingReaderContext(XlsxXmlWorksheetReaderContext* _worksheetReaderContext)
38
 
    : MSOOXML::MsooXmlReaderContext()
 
53
#include <MsooXmlContentTypes.h>
 
54
#include <MsooXmlRelationships.h>
 
55
#include <KoXmlWriter.h>
 
56
 
 
57
// calculates the column width in pixels
 
58
int columnWidth2(unsigned long col, unsigned long dx = 0, qreal defaultColumnWidth = 8.43) {
 
59
    QFont font("Arial", 10);
 
60
    QFontMetricsF fm(font);
 
61
    const qreal characterWidth = fm.width("h");
 
62
    defaultColumnWidth *= characterWidth;
 
63
    return (defaultColumnWidth * col) + (dx / 1024.0 * defaultColumnWidth);
 
64
}
 
65
 
 
66
// calculates the row height in pixels
 
67
int rowHeight2(unsigned long row, unsigned long dy = 0, qreal defaultRowHeight = 12.75)
 
68
{
 
69
    return defaultRowHeight * row + dy;
 
70
}
 
71
 
 
72
// Returns A for 1, B for 2, C for 3, etc.
 
73
QString columnName2(uint column)
 
74
{
 
75
    QString s;
 
76
    unsigned digits = 1;
 
77
    unsigned offset = 0;
 
78
    for (unsigned limit = 26; column >= limit + offset; limit *= 26, digits++)
 
79
        offset += limit;
 
80
    for (unsigned col = column - offset; digits; --digits, col /= 26)
 
81
        s.prepend(QChar('A' + (col % 26)));
 
82
    return s;
 
83
}
 
84
 
 
85
KoXmlWriter* XlsxDrawingObject::setShape(XlsxShape* shape)
 
86
{
 
87
    m_type = Shape;
 
88
    m_shape = shape;
 
89
 
 
90
    delete m_shapeBody;
 
91
    m_shapeBody = new KoXmlWriter(new QBuffer);
 
92
    return m_shapeBody;
 
93
}
 
94
 
 
95
void XlsxDrawingObject::save(KoXmlWriter* xmlWriter)
 
96
{
 
97
    switch(m_type) {
 
98
        case Unknown: {
 
99
            // nothing to do for us
 
100
        } break;
 
101
        case Chart: {
 
102
            m_chart->m_chartExport->saveIndex(xmlWriter);
 
103
        } break;
 
104
        case Diagram: {
 
105
            xmlWriter->startElement("draw:g");
 
106
            xmlWriter->addAttribute("draw:name", "SmartArt Shapes Group");
 
107
            xmlWriter->addAttribute("draw:z-index", "0");
 
108
            xmlWriter->addAttribute("table:end-cell-address", fromCellAddress());
 
109
            //xmlWriter->addAttribute("table:end-x", "0.6016in");
 
110
            //xmlWriter->addAttribute("table:end-y", "0.1339in");
 
111
            m_diagram->saveIndex(xmlWriter, positionRect());
 
112
            xmlWriter->endElement(); // draw:g
 
113
        } break;
 
114
        case Picture: {
 
115
            m_picture->saveXml(xmlWriter);
 
116
        } break;
 
117
        case Shape: {
 
118
            Q_ASSERT(m_shapeBody);
 
119
            QByteArray data = static_cast<QBuffer*>(m_shapeBody->device())->buffer().constData();
 
120
            xmlWriter->addCompleteElement(data);
 
121
            delete m_shapeBody;
 
122
            m_shapeBody = 0;
 
123
        } break;
 
124
    }
 
125
}
 
126
 
 
127
QRect XlsxDrawingObject::positionRect() const
 
128
{
 
129
    QRect rect(QPoint(0,0),QSize(0,0));
 
130
    if(m_positions.contains(FromAnchor)) {
 
131
        qreal defaultColumnWidth = 8.43;
 
132
        qreal defaultRowHeight = 12.75;
 
133
 
 
134
        Position f1 = m_positions[FromAnchor];
 
135
        rect.setX( columnWidth2(f1.m_col-1, 0 /*f.m_colOff*/, defaultColumnWidth) );
 
136
        rect.setY( rowHeight2(f1.m_row-1, 0 /*f.m_rowOff*/, defaultRowHeight) );
 
137
        if(m_positions.contains(ToAnchor)) {
 
138
            Position f2 = m_positions[ToAnchor];
 
139
            if(f2.m_col > 0 && f2.m_row > 0) {
 
140
                rect.setWidth( columnWidth2( f2.m_col - f1.m_col - 1, 0 /*t.m_colOff*/, defaultColumnWidth) );
 
141
                rect.setHeight( rowHeight2( f2.m_row - f1.m_row - 1, 0 /*t.m_rowOff*/, defaultRowHeight) );
 
142
            }
 
143
        }
 
144
    }
 
145
    return rect;
 
146
}
 
147
 
 
148
QString XlsxDrawingObject::cellAddress(const QString &sheetname, int row, int column) const
 
149
{
 
150
    QString result;
 
151
    if(!sheetname.isEmpty())
 
152
        result += sheetname + '.';
 
153
    result += columnName2(column) + QString::number(row);
 
154
    return result;
 
155
}
 
156
 
 
157
QString XlsxDrawingObject::fromCellAddress() const
 
158
{
 
159
    if(!m_positions.contains(FromAnchor)) return QString();
 
160
    Position f = m_positions[FromAnchor];
 
161
    return cellAddress(m_sheet->m_name, f.m_row, f.m_col);
 
162
}
 
163
 
 
164
QString XlsxDrawingObject::toCellAddress() const
 
165
{
 
166
    if(!m_positions.contains(ToAnchor)) return QString();
 
167
    Position f = m_positions[ToAnchor];
 
168
    return cellAddress(m_sheet->m_name, f.m_row, f.m_col);
 
169
}
 
170
 
 
171
XlsxXmlDrawingReaderContext::XlsxXmlDrawingReaderContext(XlsxXmlWorksheetReaderContext* _worksheetReaderContext, Sheet* _sheet, const QString& _path, const QString& _file)
 
172
    : MSOOXML::MsooXmlReaderContext(_worksheetReaderContext->relationships)
 
173
    , import(_worksheetReaderContext->import)
 
174
    , path(_path)
 
175
    , file(_file)
 
176
    , themes((_worksheetReaderContext->themes))
39
177
    , worksheetReaderContext(_worksheetReaderContext)
 
178
    , sheet(_sheet)
40
179
{
41
180
}
42
181
 
46
185
 
47
186
XlsxXmlDrawingReader::XlsxXmlDrawingReader(KoOdfWriters *writers)
48
187
    : MSOOXML::MsooXmlCommonReader(writers)
49
 
    , m_anchorType(XlsxXmlDrawingReaderContext::NoAnchor)
 
188
    , m_context(0)
 
189
    , m_currentDrawingObject(0)
 
190
    , m_anchorType(XlsxDrawingObject::NoAnchor)
50
191
    , m_chartNumber(0)
51
192
{
52
193
}
53
194
 
54
195
XlsxXmlDrawingReader::~XlsxXmlDrawingReader()
55
196
{
 
197
    Q_ASSERT(!m_currentDrawingObject);
56
198
}
57
199
 
58
200
KoFilter::ConversionStatus XlsxXmlDrawingReader::read(MSOOXML::MsooXmlReaderContext* context)
69
211
    if (!expectEl("xdr:wsDr")) {
70
212
        return KoFilter::WrongFormat;
71
213
    }
72
 
    
73
 
    while (!atEnd()) {
74
 
        QXmlStreamReader::TokenType tokenType = readNext();
75
 
        if(tokenType == QXmlStreamReader::Invalid || tokenType == QXmlStreamReader::EndDocument) break;
 
214
 
 
215
    while (!atEnd()) {
 
216
        QXmlStreamReader::TokenType tokenType = readNext();
 
217
        if(tokenType == QXmlStreamReader::Invalid || tokenType == QXmlStreamReader::EndDocument) break;
 
218
        if (isStartElement()) {
 
219
            const QStringRef s = qualifiedName();
 
220
            if ( s == "xdr:oneCellAnchor" || s == "xdr:twoCellAnchor" || s == "xdr:absoluteAnchor" || s == "xdr:grpSp" ) {
 
221
                read_anchor(s);
 
222
            }
 
223
        }
 
224
    }
 
225
#if 0
 
226
    m_context->saveCurrentCellData();
 
227
#endif
 
228
    m_context = 0;
 
229
    return KoFilter::OK;
 
230
}
 
231
 
 
232
#undef CURRENT_EL
 
233
#define CURRENT_EL twoCellAnchor
 
234
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_anchor(const QStringRef&)
 
235
{
 
236
    READ_PROLOGUE
 
237
 
 
238
    class DrawingObjectGuard { // like QScopedPointer but sets the pointer to NULL afterwards
 
239
        public:
 
240
            DrawingObjectGuard(XlsxDrawingObject** obj) : m_obj(obj) {}
 
241
            ~DrawingObjectGuard() { delete *m_obj; *m_obj = 0; }
 
242
        private:
 
243
            XlsxDrawingObject** m_obj;
 
244
    };
 
245
 
 
246
    Q_ASSERT(!m_currentDrawingObject);
 
247
    m_currentDrawingObject = new XlsxDrawingObject(m_context->sheet);
 
248
    DrawingObjectGuard _guard(&m_currentDrawingObject);
 
249
 
 
250
    while (!atEnd()) {
 
251
        QXmlStreamReader::TokenType tokenType = readNext();
 
252
        if(tokenType == QXmlStreamReader::Invalid || tokenType == QXmlStreamReader::EndDocument) break;
 
253
        BREAK_IF_END_OF(CURRENT_EL);
76
254
        if (isStartElement()) {
77
255
            // twoCellAnchor does define the 'from' and 'to' elements which do define the anchor-points
78
256
            TRY_READ_IF(from)
79
257
            ELSE_TRY_READ_IF(to)
80
 
            // the reference to a chart
81
 
            ELSE_TRY_READ_IF_NS(c, chart)
82
 
        }
83
 
    }
84
 
 
85
 
    m_context = 0;
86
 
    return KoFilter::OK;
 
258
            // a shape
 
259
            ELSE_TRY_READ_IF(sp)
 
260
            // the reference to a picture
 
261
            ELSE_TRY_READ_IF(pic)
 
262
            // a graphic-frame
 
263
            ELSE_TRY_READ_IF(graphicFrame)
 
264
        }
 
265
    }
 
266
 
 
267
    if (m_currentDrawingObject->m_type != XlsxDrawingObject::Unknown) {
 
268
        if (m_currentDrawingObject->m_positions.contains(XlsxDrawingObject::FromAnchor)) {
 
269
            XlsxDrawingObject::Position pos = m_currentDrawingObject->m_positions[XlsxDrawingObject::FromAnchor];
 
270
            Cell* cell = m_context->sheet->cell(pos.m_col, pos.m_row, true);
 
271
            cell->drawings.append(m_currentDrawingObject);
 
272
            m_currentDrawingObject = 0;
 
273
        }
 
274
    }
 
275
 
 
276
    READ_EPILOGUE
87
277
}
88
278
 
89
279
#undef CURRENT_EL
91
281
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_from()
92
282
{
93
283
    READ_PROLOGUE
94
 
    m_anchorType = XlsxXmlDrawingReaderContext::FromAnchor;
 
284
#if 0
 
285
    m_context->saveCurrentCellData();
 
286
#endif
 
287
    m_anchorType = XlsxDrawingObject::FromAnchor;
95
288
    while (!atEnd()) {
96
289
        readNext();
 
290
        BREAK_IF_END_OF(CURRENT_EL);
97
291
        if (isStartElement()) {
98
292
            TRY_READ_IF(col)
99
293
            ELSE_TRY_READ_IF(row)
100
294
            ELSE_TRY_READ_IF(colOff)
101
295
            ELSE_TRY_READ_IF(rowOff)
102
296
        }
103
 
        BREAK_IF_END_OF(CURRENT_EL);
104
297
    }
105
 
    m_anchorType = XlsxXmlDrawingReaderContext::NoAnchor;
 
298
    m_anchorType = XlsxDrawingObject::NoAnchor;
106
299
    READ_EPILOGUE
107
300
}
108
301
 
111
304
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_to()
112
305
{
113
306
    READ_PROLOGUE
114
 
    m_anchorType = XlsxXmlDrawingReaderContext::ToAnchor;
 
307
    m_anchorType = XlsxDrawingObject::ToAnchor;
115
308
    while (!atEnd()) {
116
309
        readNext();
 
310
        BREAK_IF_END_OF(CURRENT_EL);
117
311
        if (isStartElement()) {
118
312
            TRY_READ_IF(col)
119
313
            ELSE_TRY_READ_IF(row)
120
314
            ELSE_TRY_READ_IF(colOff)
121
315
            ELSE_TRY_READ_IF(rowOff)
122
316
        }
123
 
        BREAK_IF_END_OF(CURRENT_EL);
124
317
    }
125
 
    m_anchorType = XlsxXmlDrawingReaderContext::NoAnchor;
 
318
    m_anchorType = XlsxDrawingObject::NoAnchor;
126
319
    READ_EPILOGUE
127
320
}
128
321
 
130
323
#define CURRENT_EL col
131
324
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_col()
132
325
{
133
 
    m_context->m_positions[m_anchorType].m_col = readElementText().toInt(); // default value is zero
 
326
    m_currentDrawingObject->m_positions[m_anchorType].m_col = readElementText().toInt(); // default value is zero
134
327
    return KoFilter::OK;
135
328
}
136
329
 
138
331
#define CURRENT_EL row
139
332
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_row()
140
333
{
141
 
    m_context->m_positions[m_anchorType].m_row = readElementText().toInt(); // default value is zero
 
334
    m_currentDrawingObject->m_positions[m_anchorType].m_row = readElementText().toInt(); // default value is zero
142
335
    return KoFilter::OK;
143
336
}
144
337
 
146
339
#define CURRENT_EL colOff
147
340
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_colOff()
148
341
{
149
 
    m_context->m_positions[m_anchorType].m_colOff = readElementText().toInt(); // default value is zero
 
342
    m_currentDrawingObject->m_positions[m_anchorType].m_colOff = readElementText().toInt(); // default value is zero
150
343
    return KoFilter::OK;
151
344
}
152
345
 
154
347
#define CURRENT_EL rowOff
155
348
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_rowOff()
156
349
{
157
 
    m_context->m_positions[m_anchorType].m_rowOff = readElementText().toInt(); // default value is zero
 
350
    m_currentDrawingObject->m_positions[m_anchorType].m_rowOff = readElementText().toInt(); // default value is zero
158
351
    return KoFilter::OK;
159
352
}
160
353
 
161
354
#undef CURRENT_EL
162
 
#define CURRENT_EL chart
163
 
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_chart()
164
 
{
165
 
    Q_ASSERT(m_context);
166
 
    Q_ASSERT(m_context->worksheetReaderContext);
167
 
    Q_ASSERT(m_context->worksheetReaderContext->import);
168
 
 
 
355
#define CURRENT_EL graphicFrame
 
356
//! graphicFrame
 
357
/*!
 
358
  This element specifies the existence of a graphics frame. This frame contains a graphic that was generated
 
359
  by an external source and needs a container in which to be displayed on the slide surface.
 
360
 
 
361
  Parent Elements:
 
362
    - grpSp (§4.4.1.19); spTree (§4.4.1.42)
 
363
  Child Elements:
 
364
    - extLst (Extension List with Modification Flag) (§4.2.4)
 
365
    - graphic (Graphic Object) (§5.1.2.1.16)
 
366
    - nvGraphicFramePr (Non-Visual Properties for a Graphic Frame) (§4.4.1.27)
 
367
    - xfrm (2D Transform for Graphic Frame)
 
368
*/
 
369
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_graphicFrame()
 
370
{
 
371
    READ_PROLOGUE
 
372
    while (!atEnd()) {
 
373
        readNext();
 
374
        BREAK_IF_END_OF(CURRENT_EL);
 
375
        if (isStartElement()) {
 
376
            if (qualifiedName() == "a:graphic") {
 
377
                read_graphic2();
 
378
            }
 
379
        }
 
380
    }
 
381
    READ_EPILOGUE
 
382
}
 
383
 
 
384
#define blipFill_NS "a"
 
385
#undef MSOOXML_CURRENT_NS
 
386
#define MSOOXML_CURRENT_NS "a"
 
387
 
 
388
#undef CURRENT_EL
 
389
#define CURRENT_EL graphic
 
390
//! graphic handler (Graphic Object)
 
391
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_graphic2()
 
392
{
 
393
    READ_PROLOGUE
 
394
    while (!atEnd()) {
 
395
        readNext();
 
396
        BREAK_IF_END_OF(CURRENT_EL);
 
397
        if (isStartElement()) {
 
398
            if (qualifiedName() == "a:graphicData") {
 
399
                read_graphicData2();
 
400
            }
 
401
        }
 
402
    }
 
403
    READ_EPILOGUE
 
404
}
 
405
 
 
406
#undef CURRENT_EL
 
407
#define CURRENT_EL graphicData
 
408
//! graphicData handler (Graphic Object Data)
 
409
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_graphicData2()
 
410
{
 
411
    READ_PROLOGUE
 
412
    while (!atEnd()) {
 
413
        readNext();
 
414
        BREAK_IF_END_OF(CURRENT_EL);
 
415
        if (isStartElement()) {
 
416
            //TRY_READ_IF_NS(pic, pic)
 
417
            TRY_READ_IF_NS(pic, pic)
 
418
            if (qualifiedName() == "c:chart") {
 
419
                read_chart();
 
420
            }
 
421
            else if (qualifiedName() == QLatin1String("dgm:relIds")) {
 
422
                read_diagram(); // DrawingML diagram
 
423
            }
 
424
        }
 
425
    }
 
426
    READ_EPILOGUE
 
427
}
 
428
 
 
429
#undef CURRENT_EL
 
430
#define CURRENT_EL diagram
 
431
//! 5.9 DrawingML - Diagrams
 
432
/*!
 
433
A DrawingML diagram allows the definition of diagrams using DrawingML objects and constructs. This
 
434
namespace defines the contents of a DrawingML diagram.
 
435
*/
 
436
KoFilter::ConversionStatus XlsxXmlDrawingReader::read_diagram()
 
437
{
 
438
#if 0
169
439
    const QXmlStreamAttributes attrs(attributes());
170
 
    TRY_READ_ATTR_WITH_NS(r, id)
171
 
    if(!r_id.isEmpty()) {
172
 
        //! @todo use MSOOXML::MsooXmlRelationships
173
 
 
174
 
        const QString path = "/xl/charts";
175
 
        const QString file = QString("chart%1.xml").arg(++m_chartNumber);
176
 
        const QString filepath = path + "/" + file;
177
 
 
178
 
        XlsxXmlChartReaderContext* context = new XlsxXmlChartReaderContext(m_context);
179
 
        
180
 
        XlsxXmlChartReader reader(this);
181
 
        const KoFilter::ConversionStatus result = m_context->worksheetReaderContext->import->loadAndParseDocument(&reader, filepath, context);
182
 
        if (result != KoFilter::OK) {
183
 
            raiseError(reader.errorString());
184
 
            delete context;
185
 
            return result;
186
 
        }
187
 
 
188
 
        m_context->charts << context;
189
 
    }
190
 
 
 
440
 
 
441
    TRY_READ_ATTR_WITH_NS(r, cs) // colors
 
442
    TRY_READ_ATTR_WITH_NS(r, dm) // data
 
443
    TRY_READ_ATTR_WITH_NS(r, lo) // layout
 
444
    TRY_READ_ATTR_WITH_NS(r, qs) // quickStyle
 
445
 
 
446
    //const QString colorsfile     = r_cs.isEmpty() ? QString() : m_context->relationships->target(m_context->path, m_context->file, r_cs);
 
447
    const QString datafile       = r_dm.isEmpty() ? QString() : m_context->relationships->target(m_context->path, m_context->file, r_dm);
 
448
    const QString layoutfile     = r_lo.isEmpty() ? QString() : m_context->relationships->target(m_context->path, m_context->file, r_lo);
 
449
    //const QString quickstylefile = r_qs.isEmpty() ? QString() : m_context->relationships->target(m_context->path, m_context->file, r_qs);
 
450
 
 
451
    //kDebug()<<"colorsfile="<<colorsfile<<"datafile="<<datafile<<"layoutfile="<<layoutfile<<"quickstylefile="<<quickstylefile;
 
452
 
 
453
    //KoStore* storeout = m_context->import->outputStore();
 
454
    MSOOXML::MsooXmlDiagramReaderContext* context = new MSOOXML::MsooXmlDiagramReaderContext(mainStyles);
 
455
 
 
456
    // first read the data-model
 
457
    MSOOXML::MsooXmlDiagramReader dataReader(this);
 
458
    const KoFilter::ConversionStatus dataReaderResult = m_context->import->loadAndParseDocument(&dataReader, datafile, context);
 
459
    if (dataReaderResult != KoFilter::OK) {
 
460
       raiseError(dataReader.errorString());
 
461
       delete context;
 
462
       return dataReaderResult;
 
463
    }
 
464
 
 
465
    // then read the layout definition
 
466
    MSOOXML::MsooXmlDiagramReader layoutReader(this);
 
467
    const KoFilter::ConversionStatus layoutReaderResult = m_context->import->loadAndParseDocument(&layoutReader, layoutfile, context);
 
468
    if (layoutReaderResult != KoFilter::OK) {
 
469
       raiseError(layoutReader.errorString());
 
470
       delete context;
 
471
       return layoutReaderResult;
 
472
    }
 
473
 
 
474
    m_context->diagrams << context;
 
475
#endif
191
476
    return KoFilter::OK;
192
477
}
 
478
 
 
479
XlsxXmlEmbeddedPicture::XlsxXmlEmbeddedPicture()
 
480
{
 
481
 
 
482
}
 
483
 
 
484
void XlsxXmlEmbeddedPicture::setImageXml(const QString imageXml)
 
485
{
 
486
   m_imageXml = imageXml;
 
487
}
 
488
 
 
489
bool XlsxXmlEmbeddedPicture::saveXml(KoXmlWriter *xmlWriter)   // save all needed attributes to .ods
 
490
{
 
491
    xmlWriter->addCompleteElement(m_imageXml.toUtf8());
 
492
 
 
493
    return true;
 
494
}
 
495
 
 
496
// in PPTX we do not have pPr, so p@text:style-name should be added earlier
 
497
//#define SETUP_PARA_STYLE_IN_READ_P
 
498
#include <MsooXmlCommonReaderImpl.h> // this adds a:p, a:pPr, a:t, a:r, etc.
 
499
#define DRAWINGML_NS "a"
 
500
#define DRAWINGML_PIC_NS "xdr" // DrawingML/Picture
 
501
#define DRAWINGML_TXBODY_NS "xdr" // DrawingML/Picture
 
502
#define XLSXXMLDRAWINGREADER_CPP
 
503
#include <MsooXmlCommonReaderDrawingMLImpl.h> // this adds p:pic, etc.
 
504
//#include <MsooXmlDrawingReaderTableImpl.h> //this adds a:tbl