← Back to branch summary

~ubuntu-branches/ubuntu/precise/koffice/precise

« back to all changes in this revision

Viewing changes to filters/kspread/xlsx/XlsxXmlChartReader.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/XlsxXmlChartReader.cpp
2
2
 * This file is part of Office 2007 Filters for KOffice
3
3
 *
4
4
 * Copyright (C) 2010 Sebastian Sauer <sebsauer@kdab.com>
 
5
 * Copyright (c) 2010 Carlos Licea <carlos@kdab.com>
5
6
 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
6
7
 *
7
8
 * Contact: Suresh Chande suresh.chande@nokia.com
23
24
 */
24
25
 
25
26
#include "XlsxXmlChartReader.h"
26
 
#include "XlsxXmlDrawingReader.h"
27
 
#include "XlsxXmlWorksheetReader.h"
28
 
#include "XlsxImport.h"
29
27
 
30
28
#include "Charting.h"
31
29
#include "ChartExport.h"
 
30
#include "XlsxUtils.h"
32
31
 
33
32
#define MSOOXML_CURRENT_NS "c"
34
33
#define MSOOXML_CURRENT_CLASS XlsxXmlChartReader
39
38
 
40
39
#include <QFontMetricsF>
41
40
 
 
41
class SpPr {
 
42
public:
 
43
    SpPr() {}
 
44
};
 
45
 
 
46
class NumCache {
 
47
public:
 
48
    int m_ptCount;
 
49
    QVector< QString > m_cache;
 
50
    NumCache() : m_ptCount(0) {}
 
51
};
 
52
 
 
53
class StrCache {
 
54
public:
 
55
    int m_ptCount;
 
56
    QVector< QString >  m_cache;
 
57
    StrCache() : m_ptCount(0) {}
 
58
};
 
59
 
 
60
class NumRef {
 
61
public:
 
62
    QString m_f;
 
63
    NumCache m_numCache;
 
64
};
 
65
 
 
66
class NumLit {
 
67
public:
 
68
    int m_ptCount;
 
69
    QVector< QString > m_cache;
 
70
    NumLit() : m_ptCount(0) {}
 
71
};
 
72
 
 
73
class StrLit {
 
74
public:
 
75
    int m_ptCount;
 
76
    QVector< QString > m_cache;
 
77
    StrLit() : m_ptCount(0) {}
 
78
};
 
79
 
 
80
class StrRef {
 
81
public:
 
82
    QString m_f;
 
83
    StrCache m_strCache;
 
84
};
 
85
 
 
86
class Tx {
 
87
public:
 
88
    StrRef m_strRef;
 
89
 
 
90
    QString writeRefToInternalTable(XlsxXmlChartReader *chartReader);
 
91
};
 
92
 
 
93
QString Tx::writeRefToInternalTable(XlsxXmlChartReader *chartReader)
 
94
{
 
95
    chartReader->WriteIntoInternalTable(m_strRef.m_f,m_strRef.m_strCache.m_cache,"string");
 
96
    return m_strRef.m_f;
 
97
}
 
98
 
 
99
class Cat {
 
100
public:
 
101
    NumRef m_numRef;
 
102
    StrRef m_strRef;
 
103
    NumLit m_numLit;
 
104
    StrLit m_strLit;
 
105
 
 
106
    QString writeRefToInternalTable(XlsxXmlChartReader *chartReader);
 
107
    QString writeLitToInternalTable(XlsxXmlChartReader *chartReader);
 
108
};
 
109
 
 
110
QString Cat::writeRefToInternalTable(XlsxXmlChartReader *chartReader)
 
111
{
 
112
    if (m_numRef.m_numCache.m_ptCount != 0) {
 
113
        chartReader->WriteIntoInternalTable(m_numRef.m_f,m_numRef.m_numCache.m_cache,"float");
 
114
        return m_numRef.m_f;
 
115
    }
 
116
 
 
117
    chartReader->WriteIntoInternalTable(m_strRef.m_f,m_strRef.m_strCache.m_cache,"string");
 
118
    return m_strRef.m_f;
 
119
}
 
120
 
 
121
QString Cat::writeLitToInternalTable(XlsxXmlChartReader *chartReader)
 
122
{
 
123
    if (m_numLit.m_ptCount != 0) {
 
124
        return chartReader->AlocateAndWriteIntoInternalTable(m_numLit.m_cache,"float");
 
125
    }
 
126
 
 
127
    return chartReader->AlocateAndWriteIntoInternalTable(m_strLit.m_cache,"string");
 
128
}
 
129
 
 
130
class Val {
 
131
public:
 
132
    NumRef m_numRef;
 
133
    NumLit m_numLit;
 
134
 
 
135
    QString writeRefToInternalTable(XlsxXmlChartReader *chartReader);
 
136
    QString writeLitToInternalTable(XlsxXmlChartReader *chartReader);
 
137
};
 
138
 
 
139
QString Val::writeRefToInternalTable(XlsxXmlChartReader *chartReader)
 
140
{
 
141
    chartReader->WriteIntoInternalTable(m_numRef.m_f,m_numRef.m_numCache.m_cache,"float");
 
142
    return m_numRef.m_f;
 
143
}
 
144
 
 
145
QString Val::writeLitToInternalTable(XlsxXmlChartReader *chartReader)
 
146
{
 
147
    return chartReader->AlocateAndWriteIntoInternalTable(m_numLit.m_cache,"float");
 
148
}
 
149
 
 
150
class XVal {
 
151
public:
 
152
    NumRef m_numRef;
 
153
    StrRef m_strRef;
 
154
    NumLit m_numLit;
 
155
    StrLit m_strLit;
 
156
 
 
157
    QString writeRefToInternalTable(XlsxXmlChartReader *chartReader);
 
158
    QString writeLitToInternalTable(XlsxXmlChartReader *chartReader);
 
159
};
 
160
 
 
161
QString XVal::writeRefToInternalTable(XlsxXmlChartReader *chartReader)
 
162
{
 
163
    if (m_numRef.m_numCache.m_ptCount != 0) {
 
164
        chartReader->WriteIntoInternalTable(m_numRef.m_f,m_numRef.m_numCache.m_cache,"float");
 
165
        return m_numRef.m_f;
 
166
    }
 
167
 
 
168
    chartReader->WriteIntoInternalTable(m_strRef.m_f,m_strRef.m_strCache.m_cache,"string");
 
169
    return m_strRef.m_f;
 
170
}
 
171
 
 
172
QString XVal::writeLitToInternalTable(XlsxXmlChartReader *chartReader)
 
173
{
 
174
    if (m_numLit.m_ptCount != 0) {
 
175
        return chartReader->AlocateAndWriteIntoInternalTable(m_numLit.m_cache,"float");
 
176
    }
 
177
 
 
178
    return chartReader->AlocateAndWriteIntoInternalTable(m_strLit.m_cache,"string");
 
179
}
 
180
 
 
181
 
 
182
class YVal {
 
183
public:
 
184
    NumRef m_numRef;
 
185
    NumLit m_numLit;
 
186
 
 
187
    QString writeRefToInternalTable(XlsxXmlChartReader *chartReader);
 
188
    QString writeLitToInternalTable(XlsxXmlChartReader *chartReader);
 
189
};
 
190
 
 
191
QString YVal::writeRefToInternalTable(XlsxXmlChartReader *chartReader)
 
192
{
 
193
    chartReader->WriteIntoInternalTable(m_numRef.m_f,m_numRef.m_numCache.m_cache,"float");
 
194
    return m_numRef.m_f;
 
195
}
 
196
 
 
197
QString YVal::writeLitToInternalTable(XlsxXmlChartReader *chartReader)
 
198
{
 
199
    return chartReader->AlocateAndWriteIntoInternalTable(m_numLit.m_cache,"float");
 
200
}
 
201
 
 
202
 
 
203
class BubbleSize {
 
204
public:
 
205
    NumRef m_numRef;
 
206
    NumLit m_numLit;
 
207
 
 
208
    QString writeRefToInternalTable(XlsxXmlChartReader *chartReader);
 
209
    QString writeLitToInternalTable(XlsxXmlChartReader *chartReader);
 
210
};
 
211
 
 
212
QString BubbleSize::writeRefToInternalTable(XlsxXmlChartReader *chartReader)
 
213
{
 
214
    chartReader->WriteIntoInternalTable(m_numRef.m_f,m_numRef.m_numCache.m_cache,"float");
 
215
    return m_numRef.m_f;
 
216
}
 
217
 
 
218
QString BubbleSize::writeLitToInternalTable(XlsxXmlChartReader *chartReader)
 
219
{
 
220
    return chartReader->AlocateAndWriteIntoInternalTable(m_numLit.m_cache,"float");
 
221
}
 
222
 
 
223
class Ser
 
224
{
 
225
};
 
226
 
 
227
class ValSeries : public Ser
 
228
{
 
229
public:
 
230
    int m_idx;
 
231
    int m_order;
 
232
    Tx  m_tx;
 
233
    Cat m_cat;
 
234
    Val m_val;
 
235
    ValSeries() : m_idx(0), m_order(0) {}
 
236
};
 
237
 
 
238
class BubbleSeries : public Ser
 
239
{
 
240
public:
 
241
    int m_idx;
 
242
    int m_order;
 
243
    Tx  m_tx;
 
244
    XVal m_xVal;
 
245
    YVal m_yVal;
 
246
    BubbleSize m_bubbleSize;
 
247
    BubbleSeries() : m_idx(0), m_order(0) {}
 
248
};
 
249
 
 
250
class ScatterSeries : public Ser
 
251
{
 
252
public:
 
253
    int m_idx;
 
254
    int m_order;
 
255
    Tx  m_tx;
 
256
    XVal m_xVal;
 
257
    YVal m_yVal;
 
258
    SpPr m_spPr;
 
259
    ScatterSeries() : m_idx(0), m_order(0) {}
 
260
};
 
261
 
 
262
class LineSeries :public ValSeries
 
263
{
 
264
public:
 
265
    LineSeries() {}
 
266
};
 
267
 
 
268
class PieSeries :public ValSeries
 
269
{
 
270
public:
 
271
    int m_explosion;
 
272
    PieSeries() : m_explosion(0) {}
 
273
};
 
274
 
 
275
class BarSeries :public ValSeries
 
276
{
 
277
public:
 
278
    BarSeries() {}
 
279
};
 
280
 
 
281
class AreaSeries :public ValSeries
 
282
{
 
283
public:
 
284
    AreaSeries() {}
 
285
};
 
286
 
 
287
class RadarSeries :public ValSeries
 
288
{
 
289
public:
 
290
    RadarSeries() {}
 
291
};
 
292
 
 
293
class SurfaceSeries :public ValSeries
 
294
{
 
295
public:
 
296
    SurfaceSeries() {}
 
297
};
 
298
 
 
299
class XlsxXmlChartReader::Private
 
300
{
 
301
public:
 
302
    Private();
 
303
    QList<Ser*> m_seriesData;
 
304
    QVariant::Type m_currentType;
 
305
    int *m_currentIdx;
 
306
    int *m_currentOrder;
 
307
    int *m_currentExplosion;
 
308
    Tx  *m_currentTx;
 
309
    Cat *m_currentCat;
 
310
    Val *m_currentVal;
 
311
    StrRef *m_currentStrRef;
 
312
    QString *m_currentF;
 
313
    StrCache *m_currentStrCache;
 
314
    int *m_currentPtCount;
 
315
    QVector< QString >  *m_currentPtCache;
 
316
    NumRef *m_currentNumRef;
 
317
    NumLit *m_currentNumLit;
 
318
    NumCache *m_currentNumCache;
 
319
    XVal *m_currentXVal;
 
320
    YVal *m_currentYVal;
 
321
    BubbleSize *m_currentBubbleSize;
 
322
    int m_numReadSeries;
 
323
};
 
324
 
 
325
XlsxXmlChartReader::Private::Private ( )
 
326
    : m_numReadSeries( 0 )
 
327
{
 
328
    qDeleteAll(m_seriesData);
 
329
}
 
330
 
42
331
// calculates the column width in pixels
43
332
int columnWidth(unsigned long col, unsigned long dx = 0, qreal defaultColumnWidth = 8.43) {
44
333
    QFont font("Arial", 10);
58
347
QString columnName(uint column)
59
348
{
60
349
    QString s;
 
350
    column = column - 1;
61
351
    unsigned digits = 1;
62
352
    unsigned offset = 0;
63
353
    for (unsigned limit = 26; column >= limit + offset; limit *= 26, digits++)
67
357
    return s;
68
358
}
69
359
 
70
 
XlsxXmlChartReaderContext::XlsxXmlChartReaderContext(XlsxXmlDrawingReaderContext* _drawingReaderContext)
 
360
 
 
361
 
 
362
XlsxXmlChartReaderContext::XlsxXmlChartReaderContext(KoStore* _storeout, ChartExport* _chartExport)
71
363
    : MSOOXML::MsooXmlReaderContext()
72
 
    , drawingReaderContext(_drawingReaderContext)
73
 
    , m_chart(0)
74
 
    , m_chartExport(0)
 
364
    , m_storeout(_storeout)
 
365
    , m_chart(_chartExport->chart())
 
366
    , m_chartExport(_chartExport)
75
367
{
76
368
}
77
369
 
78
370
XlsxXmlChartReaderContext::~XlsxXmlChartReaderContext()
79
371
{
80
372
    delete m_chart;
 
373
    delete m_chartExport;
81
374
}
82
375
 
83
376
XlsxXmlChartReader::XlsxXmlChartReader(KoOdfWriters *writers)
84
377
    : MSOOXML::MsooXmlCommonReader(writers)
85
378
    , m_context(0)
86
379
    , m_currentSeries(0)
 
380
    , m_autoTitleDeleted(false)
 
381
    , m_readTxContext( None )
 
382
    , m_areaContext( ChartArea )
 
383
    , d ( new Private( ) )
87
384
{
88
385
}
89
386
 
90
387
XlsxXmlChartReader::~XlsxXmlChartReader()
91
388
{
 
389
     delete d;
92
390
}
93
391
 
 
392
//! chart (Chart)
 
393
/*! ECMA-376, 21.2.2.29, p.3768.
 
394
 
 
395
 Parent elements:
 
396
  - chartSpace (§21.2.2.29)
 
397
 
 
398
 Child elements:
 
399
  - [Done]autoTitleDeleted (Auto Title Is Deleted) §21.2.2.7
 
400
  - backWall (Back Wall) §21.2.2.11
 
401
  - dispBlanksAs (Display Blanks As) §21.2.2.42
 
402
  - extLst (Chart Extensibility) §21.2.2.64
 
403
  - floor (Floor) §21.2.2.69
 
404
  - [Done]legend (Legend) §21.2.2.93
 
405
  - pivotFmts (Pivot Formats) §21.2.2.143
 
406
  - [Done]plotArea (Plot Area) §21.2.2.145
 
407
  - plotVisOnly (Plot Visible Only) §21.2.2.146
 
408
  - showDLblsOverMax (Show Data Labels over Maximum) §21.2.2.180
 
409
  - sideWall (Side Wall) §21.2.2.191
 
410
  - [Done]title (Title) §21.2.2.210
 
411
  - view3D (View In 3D) §21.2.2.228
 
412
*/
94
413
KoFilter::ConversionStatus XlsxXmlChartReader::read(MSOOXML::MsooXmlReaderContext* context)
95
414
{
96
415
    m_context = dynamic_cast<XlsxXmlChartReaderContext*>(context);
97
416
    Q_ASSERT(m_context);
98
 
    Q_ASSERT(m_context->drawingReaderContext);
99
 
    Q_ASSERT(m_context->drawingReaderContext->worksheetReaderContext);
100
417
 
101
418
    readNext();
102
419
    if (!isStartDocument()) {
108
425
        return KoFilter::WrongFormat;
109
426
    }
110
427
 
111
 
    delete m_context->m_chart;
112
 
    m_context->m_chart = new Charting::Chart;
113
 
 
114
 
    delete m_context->m_chartExport;
115
 
    m_context->m_chartExport = new ChartExport(m_context->m_chart);
116
 
 
117
428
    while (!atEnd()) {
118
429
        QXmlStreamReader::TokenType tokenType = readNext();
119
430
        if(tokenType == QXmlStreamReader::Invalid || tokenType == QXmlStreamReader::EndDocument) break;
120
431
        if (isStartElement()) {
 
432
            m_areaContext = ChartArea;
121
433
            TRY_READ_IF(plotArea)
 
434
            ELSE_TRY_READ_IF(title)
122
435
            ELSE_TRY_READ_IF(legend)
 
436
            ELSE_TRY_READ_IF(spPr)
 
437
            if (qualifiedName() == QLatin1String(QUALIFIED_NAME(autoTitleDeleted))) {
 
438
                const QXmlStreamAttributes attrs(attributes());
 
439
                TRY_READ_ATTR_WITHOUT_NS(val)
 
440
                m_autoTitleDeleted = val.toInt();
 
441
            }
 
442
           if (qualifiedName() == QLatin1String(QUALIFIED_NAME(style))) {
 
443
               const QXmlStreamAttributes attrs(attributes());
 
444
               TRY_READ_ATTR_WITHOUT_NS(val)
 
445
               m_context->m_chart->m_style = val.toInt();
 
446
           }
123
447
        }
124
448
    }
125
449
 
126
450
    // static is fine here cause we only need to take care that that number is unique in the
127
451
    // exported ODS file and do not take if the number is continuous or whatever.
128
452
    static int chartNumber = 0;
129
 
 
130
453
    m_context->m_chartExport->m_href = QString("Chart%1").arg(++chartNumber);
131
 
    QMap<XlsxXmlDrawingReaderContext::AnchorType, XlsxXmlDrawingReaderContext::Position> positions = m_context->drawingReaderContext->m_positions;
132
 
    const QString sheetName = m_context->drawingReaderContext->worksheetReaderContext->worksheetName;
133
 
    if(! sheetName.isEmpty()) {
134
 
        m_context->m_chartExport->m_endCellAddress += sheetName + '.';
 
454
 
 
455
    Charting::Chart* c = m_context->m_chart;
 
456
    if(!c->m_sheetName.isEmpty()) {
 
457
        m_context->m_chartExport->m_endCellAddress += c->m_sheetName + '.';
135
458
    }
136
 
 
137
 
    if(positions.contains(XlsxXmlDrawingReaderContext::FromAnchor)) {
138
 
        XlsxXmlDrawingReaderContext::Position f = positions[XlsxXmlDrawingReaderContext::FromAnchor];
139
 
        m_context->m_chartExport->m_endCellAddress += columnName(f.m_col) + QString::number(f.m_row);
140
 
        m_context->m_chartExport->m_x = columnWidth(f.m_col-1, 0 /*f.m_colOff*/);
141
 
        m_context->m_chartExport->m_y = rowHeight(f.m_row-1, 0 /*f.m_rowOff*/);
142
 
        if(positions.contains(XlsxXmlDrawingReaderContext::ToAnchor)) {
143
 
            XlsxXmlDrawingReaderContext::Position t = positions[XlsxXmlDrawingReaderContext::ToAnchor];
144
 
            m_context->m_chartExport->m_width = columnWidth( t.m_col - f.m_col - 1, 0 /*t.m_colOff*/);
145
 
            m_context->m_chartExport->m_height = rowHeight( t.m_row - f.m_row - 1, 0 /*t.m_rowOff*/);
 
459
    if(c->m_fromColumn > 0 && c->m_fromRow > 0) {
 
460
        m_context->m_chartExport->m_endCellAddress += columnName(c->m_fromColumn) + QString::number(c->m_fromRow);
 
461
        m_context->m_chartExport->m_x = columnWidth(c->m_fromColumn-1, 0 /*f.m_colOff*/);
 
462
        m_context->m_chartExport->m_y = rowHeight(c->m_fromRow-1, 0 /*f.m_rowOff*/);
 
463
        if(c->m_toColumn > 0 && c->m_toRow > 0) {
 
464
            m_context->m_chartExport->m_width = columnWidth( c->m_toColumn - c->m_fromColumn - 1, 0 /*t.m_colOff*/);
 
465
            m_context->m_chartExport->m_height = rowHeight( c->m_toRow - c->m_fromRow - 1, 0 /*t.m_rowOff*/);
146
466
        }
147
467
    }
148
468
 
149
 
 
150
 
    if (!m_context->m_chart->m_cellRangeAddress.isNull() ) {
 
469
    if (!c->m_cellRangeAddress.isNull() ) {
151
470
        m_context->m_chartExport->m_cellRangeAddress.clear();
152
 
        if (!sheetName.isEmpty()) m_context->m_chartExport->m_cellRangeAddress += sheetName + '.';
153
 
        m_context->m_chartExport->m_cellRangeAddress += columnName(m_context->m_chart->m_cellRangeAddress.left()) + QString::number(m_context->m_chart->m_cellRangeAddress.top()) + ":" +
154
 
                                                        columnName(m_context->m_chart->m_cellRangeAddress.right()) + QString::number(m_context->m_chart->m_cellRangeAddress.bottom());
 
471
        if (!c->m_sheetName.isEmpty())
 
472
            m_context->m_chartExport->m_cellRangeAddress += c->m_sheetName + '.';
 
473
        m_context->m_chartExport->m_cellRangeAddress += columnName(c->m_cellRangeAddress.left()) + QString::number(c->m_cellRangeAddress.top()) + ":" +
 
474
                                                        columnName(c->m_cellRangeAddress.right()) + QString::number(c->m_cellRangeAddress.bottom());
155
475
    }
156
476
 
157
 
    m_context->m_chartExport->m_notifyOnUpdateOfRanges = m_currentSeries->m_valuesCellRangeAddress; //m_cellRangeAddress
 
477
    if (m_currentSeries) {
 
478
        m_context->m_chartExport->m_notifyOnUpdateOfRanges = m_currentSeries->m_valuesCellRangeAddress; //m_cellRangeAddress
 
479
    }
158
480
    
159
481
    // the index will by written by the XlsxXmlWorksheetReader
160
482
    //m_context->m_chartExport->saveIndex(body);
161
483
 
162
484
    // write the embedded object file
163
 
    KoStore* storeout = m_context->drawingReaderContext->worksheetReaderContext->import->outputStore();
164
 
    m_context->m_chartExport->saveContent(storeout, manifest);
165
 
 
 
485
    m_context->m_chartExport->saveContent(m_context->m_storeout, manifest);
 
486
    
166
487
    m_context = 0;
167
488
    return KoFilter::OK;
168
489
}
169
490
 
170
491
#undef CURRENT_EL
 
492
#define CURRENT_EL valAx
 
493
KoFilter::ConversionStatus XlsxXmlChartReader::read_valAx()
 
494
{
 
495
    READ_PROLOGUE
 
496
    Charting::Axis* axis = new Charting::Axis( Charting::Axis::VerticalValueAxis );
 
497
 
 
498
    m_context->m_chart->m_axes.push_back( axis );
 
499
    while (!atEnd()) {
 
500
        readNext();
 
501
        BREAK_IF_END_OF(CURRENT_EL);
 
502
        if (isStartElement()) {
 
503
            if ( qualifiedName() == QLatin1String( QUALIFIED_NAME(axPos) ) ) {
 
504
                  const QXmlStreamAttributes attrs(attributes());
 
505
                  TRY_READ_ATTR_WITHOUT_NS(val)
 
506
                  if ( val == QLatin1String( "b" ) ){
 
507
                      axis->m_type = Charting::Axis::HorizontalValueAxis;
 
508
                  }
 
509
//                   else if ( val == QLatin1String( "l" ) ){
 
510
//                   }
 
511
            }
 
512
        }
 
513
        else if ( qualifiedName() == QLatin1String( QUALIFIED_NAME(majorGridlines) ) ) {
 
514
            axis->m_majorGridlines = Charting::Axis::Gridline( Charting::LineFormat( Charting::LineFormat::Solid ) );
 
515
        }
 
516
    }
 
517
    READ_EPILOGUE
 
518
}
 
519
 
 
520
#undef CURRENT_EL
 
521
#define CURRENT_EL catAx
 
522
KoFilter::ConversionStatus XlsxXmlChartReader::read_catAx()
 
523
{
 
524
    READ_PROLOGUE
 
525
    Charting::Axis* axis = new Charting::Axis( Charting::Axis::VerticalValueAxis );
 
526
    m_context->m_chart->m_axes.push_back( axis );
 
527
    while (!atEnd()) {
 
528
        readNext();
 
529
        BREAK_IF_END_OF(CURRENT_EL);
 
530
        if (isStartElement()) {
 
531
            if ( qualifiedName() == QLatin1String( QUALIFIED_NAME(axPos) ) ) {
 
532
                  const QXmlStreamAttributes attrs(attributes());
 
533
                  TRY_READ_ATTR_WITHOUT_NS(val)
 
534
                  if ( val == QLatin1String( "b" ) ){
 
535
                      axis->m_type = Charting::Axis::HorizontalValueAxis;
 
536
                  }
 
537
//                   else if ( val == QLatin1String( "l" ) ){
 
538
//                   }
 
539
            }
 
540
            else if ( qualifiedName() == QLatin1String( QUALIFIED_NAME(majorGridlines) ) ) {
 
541
                  axis->m_majorGridlines = Charting::Axis::Gridline( Charting::LineFormat( Charting::LineFormat::Solid ) );
 
542
            }
 
543
        }
 
544
    }
 
545
    READ_EPILOGUE
 
546
}
 
547
 
 
548
#undef CURRENT_EL
171
549
#define CURRENT_EL plotArea
 
550
//! plotArea (Plot Area)
 
551
/*! ECMA-376, 21.2.2.145, p.3828.
 
552
 
 
553
 Parent elements:
 
554
  - chart (§21.2.2.27)
 
555
 
 
556
 Child elements:
 
557
  - [Done]area3DChart (3D Area Charts) §21.2.2.4
 
558
  - [Done]areaChart (Area Charts) §21.2.2.5
 
559
  - [Done]bar3DChart (3D Bar Charts) §21.2.2.15
 
560
  - [Done]barChart (Bar Charts) §21.2.2.16
 
561
  - [Done]bubbleChart (Bubble Charts) §21.2.2.20
 
562
  - [Done]catAx (Category Axis Data) §21.2.2.25
 
563
  - dateAx (Date Axis) §21.2.2.39
 
564
  - [Done]doughnutChart (Doughnut Charts) §21.2.2.50
 
565
  - dTable (Data Table) §21.2.2.54
 
566
  - extLst (Chart Extensibility) §21.2.2.64
 
567
  - layout (Layout) §21.2.2.88
 
568
  - [Done]line3DChart (3D Line Charts) §21.2.2.96
 
569
  - [Done]lineChart (Line Charts) §21.2.2.97
 
570
  - ofPieChart (Pie of Pie or Bar of Pie Charts) §21.2.2.126
 
571
  - [Done]pie3DChart (3D Pie Charts) §21.2.2.140
 
572
  - [Done]pieChart (Pie Charts) §21.2.2.141
 
573
  - [Done]radarChart (Radar Charts) §21.2.2.153
 
574
  - [Done]scatterChart (Scatter Charts) §21.2.2.161
 
575
  - serAx (Series Axis) §21.2.2.175
 
576
  - [Done]spPr (Shape Properties) §21.2.2.197
 
577
  - [Done]stockChart (Stock Charts) §21.2.2.198
 
578
  - [Done]surface3DChart (3D Surface Charts) §21.2.2.203
 
579
  - [Done]surfaceChart (Surface Charts) §21.2.2.204
 
580
  - [Done]valAx (Value Axis) §21.2.2.226
 
581
*/
172
582
KoFilter::ConversionStatus XlsxXmlChartReader::read_plotArea()
173
583
{
 
584
    m_areaContext = PlotArea;
174
585
    READ_PROLOGUE
175
586
    while (!atEnd()) {
176
587
        readNext();
 
588
        BREAK_IF_END_OF(CURRENT_EL);
177
589
        if (isStartElement()) {
178
 
            TRY_READ_IF(ser)
 
590
            TRY_READ_IF(spPr)
 
591
            ELSE_TRY_READ_IF(valAx)
 
592
            ELSE_TRY_READ_IF(catAx)
179
593
            ELSE_TRY_READ_IF(pieChart)
180
 
            ELSE_TRY_READ_IF(firstSliceAng)
 
594
            ELSE_TRY_READ_IF(pie3DChart)
 
595
            ELSE_TRY_READ_IF(doughnutChart)
 
596
            ELSE_TRY_READ_IF(areaChart)
 
597
            ELSE_TRY_READ_IF(area3DChart)
 
598
            ELSE_TRY_READ_IF(barChart)
 
599
            ELSE_TRY_READ_IF(bar3DChart)
 
600
            ELSE_TRY_READ_IF(lineChart)
 
601
            ELSE_TRY_READ_IF(line3DChart)
 
602
            ELSE_TRY_READ_IF(scatterChart)
 
603
            ELSE_TRY_READ_IF(radarChart)
 
604
            ELSE_TRY_READ_IF(surfaceChart)
 
605
            ELSE_TRY_READ_IF(surface3DChart)
 
606
            ELSE_TRY_READ_IF(bubbleChart)
 
607
            ELSE_TRY_READ_IF(stockChart)
181
608
        }
182
 
        BREAK_IF_END_OF(CURRENT_EL);
183
609
    }
184
610
    READ_EPILOGUE
 
611
    m_areaContext = ChartArea;
185
612
}
186
613
 
187
614
#undef CURRENT_EL
188
 
#define CURRENT_EL ser
189
 
KoFilter::ConversionStatus XlsxXmlChartReader::read_ser()
 
615
#define CURRENT_EL title
 
616
/*! Read the horizontal value. */
 
617
KoFilter::ConversionStatus XlsxXmlChartReader::read_title()
190
618
{
 
619
    m_readTxContext = Title;
191
620
    READ_PROLOGUE
192
 
    
193
 
    m_currentSeries = new Charting::Series;
194
 
    m_context->m_chart->m_series << m_currentSeries;
195
 
    //m_currentSeries->m_dataTypeX = record->dataTypeX();
196
 
    //m_currentSeries->m_countXValues = record->countXValues();
197
 
    //m_currentSeries->m_countYValues = record->countYValues();
198
 
    //m_currentSeries->m_countBubbleSizeValues = record->countBubbleSizeValues();
199
 
 
200
621
    while (!atEnd()) {
201
622
        readNext();
 
623
        BREAK_IF_END_OF(CURRENT_EL);
202
624
        if (isStartElement()) {
203
 
            TRY_READ_IF(val)
204
 
            //ELSE_TRY_READ_IF(idx)
205
 
            //ELSE_TRY_READ_IF(order)
 
625
            if(!m_autoTitleDeleted)
 
626
                if (QUALIFIED_NAME_IS(tx)) {
 
627
                    TRY_READ(chartText_Tx)
 
628
                }
206
629
        }
207
 
        BREAK_IF_END_OF(CURRENT_EL);
208
630
    }
209
 
 
 
631
    if ( m_context->m_chart->m_title.isEmpty() )
 
632
        m_context->m_chart->m_title = "Chart Title";
 
633
    m_readTxContext = None;
210
634
    READ_EPILOGUE
211
635
}
212
636
 
213
637
#undef CURRENT_EL
214
638
#define CURRENT_EL val
 
639
//! val (Values)
 
640
/*! ECMA-376, 21.2.2.224, p.3867.
 
641
 
 
642
 Parent elements:
 
643
  - ser §21.2.2.168
 
644
  - ser §21.2.2.170
 
645
  - ser §21.2.2.174
 
646
  - ser §21.2.2.171
 
647
  - ser §21.2.2.172
 
648
  - ser §21.2.2.169
 
649
  - ser §21.2.2.167
 
650
  - ser §21.2.2.173
 
651
 
 
652
 Child elements:
 
653
  - numLit (Number Literal) §21.2.2.122
 
654
  - [Done]numRef (Number Reference) §21.2.2.123
 
655
*/
215
656
KoFilter::ConversionStatus XlsxXmlChartReader::read_val()
216
657
{
217
658
    READ_PROLOGUE
218
 
    while (!atEnd()) {
219
 
        readNext();
220
 
        if (isStartElement()) {
221
 
            TRY_READ_IF(numCache)
222
 
            if (qualifiedName() == QLatin1String(QUALIFIED_NAME(f))) {
223
 
                m_currentSeries->m_valuesCellRangeAddress = readElementText();
224
 
            }
225
 
        }
226
 
        BREAK_IF_END_OF(CURRENT_EL);
 
659
    d->m_currentNumRef = &d->m_currentVal->m_numRef;
 
660
    while (!atEnd()) {
 
661
        readNext();
 
662
        BREAK_IF_END_OF(CURRENT_EL);
 
663
        if (isStartElement()) {
 
664
            TRY_READ_IF(numRef)
 
665
        }
 
666
    }
 
667
    READ_EPILOGUE
 
668
}
 
669
 
 
670
#undef CURRENT_EL
 
671
#define CURRENT_EL xVal
 
672
//! xVal (X Values)
 
673
/*! ECMA-376, 21.2.2.234, p.3872.
 
674
 
 
675
 Parent elements:
 
676
  - ser §21.2.2.174
 
677
  - ser §21.2.2.167
 
678
 
 
679
 Child elements:
 
680
  - multiLvlStrRef (Multi Level String Reference) §21.2.2.115
 
681
  - numLit (Number Literal) §21.2.2.122
 
682
  - [Done]numRef (Number Reference) §21.2.2.123
 
683
  - strLit (String Literal) §21.2.2.200
 
684
  - [Done]strRef (String Reference) §21.2.2.201
 
685
*/
 
686
KoFilter::ConversionStatus XlsxXmlChartReader::read_xVal()
 
687
{
 
688
    READ_PROLOGUE
 
689
    d->m_currentNumRef = &d->m_currentXVal->m_numRef;
 
690
    d->m_currentStrRef = &d->m_currentXVal->m_strRef;
 
691
    while (!atEnd()) {
 
692
        readNext();
 
693
        BREAK_IF_END_OF(CURRENT_EL);
 
694
        if (isStartElement()) {
 
695
            TRY_READ_IF(numRef)
 
696
            ELSE_TRY_READ_IF(strRef)
 
697
        }
 
698
    }
 
699
    READ_EPILOGUE
 
700
}
 
701
 
 
702
#undef CURRENT_EL
 
703
#define CURRENT_EL yVal
 
704
//! yVal (Y Values)
 
705
/*! ECMA-376, 21.2.2.237, p.3873.
 
706
 
 
707
 Parent elements:
 
708
  - ser §21.2.2.174
 
709
  - ser §21.2.2.167
 
710
 
 
711
 Child elements:
 
712
  - numLit (Number Literal) §21.2.2.122
 
713
  - numRef (Number Reference) §21.2.2.123
 
714
*/
 
715
KoFilter::ConversionStatus XlsxXmlChartReader::read_yVal()
 
716
{
 
717
    READ_PROLOGUE
 
718
    d->m_currentNumRef = &d->m_currentYVal->m_numRef;
 
719
    while (!atEnd()) {
 
720
        readNext();
 
721
        BREAK_IF_END_OF(CURRENT_EL);
 
722
        if (isStartElement()) {
 
723
            TRY_READ_IF(numRef)
 
724
        }
 
725
    }
 
726
    READ_EPILOGUE
 
727
}
 
728
 
 
729
#undef CURRENT_EL
 
730
#define CURRENT_EL cat
 
731
//! cat (Category Axis Data)
 
732
/*! ECMA-376, 21.2.2.24, p.3766.
 
733
 
 
734
 Parent elements:
 
735
  - ser §21.2.2.168
 
736
  - ser §21.2.2.170
 
737
  - ser §21.2.2.174
 
738
  - ser §21.2.2.171
 
739
  - ser §21.2.2.172
 
740
  - ser §21.2.2.169
 
741
  - ser §21.2.2.167
 
742
  - ser §21.2.2.173
 
743
 
 
744
 Child elements:
 
745
  - multiLvlStrRef (Multi Level String Reference) §21.2.2.115
 
746
  - numLit (Number Literal) §21.2.2.122
 
747
  - [Done]numRef (Number Reference) §21.2.2.123
 
748
  - strLit (String Literal) §21.2.2.200
 
749
  - strRef (String Reference) §21.2.2.201
 
750
*/
 
751
KoFilter::ConversionStatus XlsxXmlChartReader::read_cat()
 
752
{
 
753
    READ_PROLOGUE
 
754
    d->m_currentStrRef = &d->m_currentCat->m_strRef;
 
755
    d->m_currentNumRef = &d->m_currentCat->m_numRef;
 
756
    while (!atEnd()) {
 
757
        readNext();
 
758
        BREAK_IF_END_OF(CURRENT_EL);
 
759
        if (isStartElement()) {
 
760
            TRY_READ_IF(strRef)
 
761
            ELSE_TRY_READ_IF(numRef)
 
762
        }
 
763
    }
 
764
    READ_EPILOGUE
 
765
}
 
766
 
 
767
#undef CURRENT_EL
 
768
#define CURRENT_EL tx
 
769
//! tx (Chart Text)
 
770
/*! ECMA-376, 21.2.2.215, p.3863.
 
771
 
 
772
 Parent elements:
 
773
  - dispUnitsLbl (§21.2.2.46)
 
774
  - dLbl (§21.2.2.47)
 
775
  - title (§21.2.2.210)
 
776
  - trendlineLbl (§21.2.2.212)
 
777
 
 
778
 Child elements:
 
779
  - rich (Rich Text) §21.2.2.156
 
780
  - strRef (String Reference) §21.2.2.201
 
781
*/
 
782
 
 
783
/*! This element specifies text to use on a chart, including rich text formatting. */
 
784
KoFilter::ConversionStatus XlsxXmlChartReader::read_chartText_Tx()
 
785
{
 
786
    READ_PROLOGUE2(chartText_Tx)
 
787
    enum { Start, InStrRef, InRichText } state;
 
788
    state = Start;
 
789
    while (!atEnd()) {
 
790
        readNext();
 
791
        BREAK_IF_END_OF(CURRENT_EL);
 
792
        switch(state) {
 
793
            case Start:
 
794
                if (qualifiedName() == QLatin1String(QUALIFIED_NAME(strRef)))
 
795
                    state = isStartElement() ? InStrRef : Start;
 
796
                else if (qualifiedName() == QLatin1String(QUALIFIED_NAME(rich)))
 
797
                    state = isStartElement() ? InRichText : Start;
 
798
                break;
 
799
            case InStrRef: // plaintext within a series
 
800
//                if (isStartElement() && !m_currentSeriesData->m_datasetValue.contains(Charting::Value::SeriesLegendOrTrendlineName)) {
 
801
//                    if (qualifiedName() == QLatin1String(QUALIFIED_NAME(f))) {
 
802
//                        Charting::Value* v = new Charting::Value(Charting::Value::SeriesLegendOrTrendlineName, Charting::Value::CellRange, readElementText());
 
803
//                        m_currentSeriesData->m_datasetValue[v->m_dataId] = v;
 
804
//                    } else if (qualifiedName() == QLatin1String(QUALIFIED_NAME(v))) {
 
805
//                        Charting::Value* v = new Charting::Value(Charting::Value::SeriesLegendOrTrendlineName, Charting::Value::TextOrValue, readElementText());
 
806
//                        m_currentSeriesData->m_datasetValue[v->m_dataId] = v;
 
807
//                    }
 
808
//                }
 
809
                break;
 
810
            case InRichText: // richtext means the title text
 
811
                // we extract the text from the richtext cause we cannot handle the richtext formattings anyway
 
812
                QString result;
 
813
                enum { Rich, Paragraph, TextRun } s;
 
814
                s = Rich;
 
815
                while (!atEnd()) {
 
816
                    readNext();
 
817
                    switch(s) {
 
818
                        case Rich:
 
819
                            if (isStartElement() && qualifiedName() == QLatin1String("a:p")) s = Paragraph;
 
820
                            break;
 
821
                        case Paragraph:
 
822
                            if (qualifiedName() == QLatin1String("a:r")) // text run
 
823
                            s = isStartElement() ? TextRun : Rich;
 
824
                        break;
 
825
                        case TextRun:
 
826
                            if (qualifiedName() == QLatin1String("a:t")) {
 
827
                                if(isStartElement()) {
 
828
                                    if(!result.isEmpty()) result += ' '; //concat multiple strings into one result
 
829
                                    const QString text = readElementText();
 
830
                                    result += text;
 
831
                                    m_context->m_chart->m_title = text;
 
832
                                } else
 
833
                                    s = Paragraph;
 
834
                            }
 
835
                            break;
 
836
                    }
 
837
                    BREAK_IF_END_OF(rich);
 
838
                }
 
839
                if(!result.isEmpty())
 
840
                    m_context->m_chart->m_texts << new Charting::Text(result);
 
841
                state = Start;
 
842
                break;
 
843
        }
 
844
    }
 
845
    READ_EPILOGUE
 
846
}
 
847
 
 
848
#undef CURRENT_EL
 
849
#define CURRENT_EL tx
 
850
//! tx (Series Text)
 
851
/*! ECMA-376, 21.2.2.215, p.3863.
 
852
 
 
853
 Parent elements:
 
854
  - ser §21.2.2.168
 
855
  - ser §21.2.2.170
 
856
  - ser §21.2.2.174
 
857
  - ser §21.2.2.171
 
858
  - ser §21.2.2.172
 
859
  - ser §21.2.2.169
 
860
  - ser §21.2.2.167
 
861
  - ser §21.2.2.173
 
862
 
 
863
 Child elements:
 
864
  - [Done]strRef (String Reference) §21.2.2.201
 
865
  - v (Text Value) §21.2.2.223
 
866
*/
 
867
 
 
868
/*! This element specifies text to use on a chart, including rich text formatting. */
 
869
KoFilter::ConversionStatus XlsxXmlChartReader::read_seriesText_Tx()
 
870
{
 
871
    READ_PROLOGUE2(seriesText_Tx)
 
872
 
 
873
    d->m_currentStrRef = &d->m_currentTx->m_strRef;
 
874
    while (!atEnd()) {
 
875
        readNext();
 
876
        BREAK_IF_END_OF(CURRENT_EL);
 
877
        if (isStartElement()) {
 
878
            TRY_READ_IF(strRef)
 
879
        }
227
880
    }
228
881
    READ_EPILOGUE
229
882
}
230
883
 
231
884
#undef CURRENT_EL
232
885
#define CURRENT_EL numCache
 
886
//! numCache (Number Cache)
 
887
/*! ECMA-376, 21.2.2.120, p.3813.
 
888
 
 
889
 Parent elements:
 
890
 - numRef (§21.2.2.123)
 
891
 
 
892
 Child elements:
 
893
  - extLst (Chart Extensibility) §21.2.2.64
 
894
  - formatCode (Format Code) §21.2.2.71
 
895
  - [Done]pt (Numeric Point) §21.2.2.150
 
896
  - [Done]ptCount (Point Count) §21.2.2.152
 
897
 
 
898
*/
233
899
KoFilter::ConversionStatus XlsxXmlChartReader::read_numCache()
234
900
{
235
901
    READ_PROLOGUE
 
902
 
 
903
    d->m_currentPtCount = &d->m_currentNumCache->m_ptCount;
 
904
    d->m_currentPtCache = &d->m_currentNumCache->m_cache;
 
905
 
236
906
    while (!atEnd()) {
237
907
        readNext();
 
908
        BREAK_IF_END_OF(CURRENT_EL);
238
909
        if (isStartElement()) {
239
 
            if (qualifiedName() == QLatin1String(QUALIFIED_NAME(ptCount))) {
240
 
                const QXmlStreamAttributes attrs(attributes());
241
 
                TRY_READ_ATTR_WITHOUT_NS(val)
242
 
                m_currentSeries->m_countYValues = val.toInt();
243
 
            }
244
 
            //else if (qualifiedName() == QLatin1String(QUALIFIED_NAME(pt)))
245
 
            //else if (qualifiedName() == QLatin1String(QUALIFIED_NAME(formatCode)))
 
910
            TRY_READ_IF(ptCount)
 
911
            ELSE_TRY_READ_IF(pt)
246
912
        }
247
 
        BREAK_IF_END_OF(CURRENT_EL);
248
913
    }
249
914
    READ_EPILOGUE
250
915
}
253
918
#define CURRENT_EL legend
254
919
KoFilter::ConversionStatus XlsxXmlChartReader::read_legend()
255
920
{
256
 
    //TODO
257
 
    return KoFilter::OK;
 
921
    READ_PROLOGUE
 
922
    while (!atEnd()) {
 
923
        readNext();
 
924
        BREAK_IF_END_OF(CURRENT_EL);
 
925
        //TODO
 
926
    }
 
927
    READ_EPILOGUE
 
928
}
 
929
 
 
930
#undef CURRENT_EL
 
931
#define CURRENT_EL dLbl
 
932
//! dLbl (Data Label)
 
933
/*! ECMA-376, 21.2.2.47, p.3780.
 
934
 
 
935
 Parent elements:
 
936
 - dLbls (§21.2.2.49)
 
937
 - pivotFmt (§21.2.2.142)
 
938
 
 
939
 Child elements:
 
940
  - delete (Delete) §21.2.2.40
 
941
  - dLblPos (Data Label Position) §21.2.2.48
 
942
  - extLst (Chart Extensibility) §21.2.2.64
 
943
  - idx (Index) §21.2.2.84
 
944
  - layout (Layout) §21.2.2.88
 
945
  - numFmt (Number Format) §21.2.2.121
 
946
  - separator (Separator) §21.2.2.166
 
947
  - showBubbleSize (Show Bubble Size) §21.2.2.178
 
948
  - showCatName (Show Category Name) §21.2.2.179
 
949
  - showLegendKey (Show Legend Key) §21.2.2.184
 
950
  - showPercent (Show Percent) §21.2.2.187
 
951
  - showSerName (Show Series Name) §21.2.2.188
 
952
  - [Done]showVal (Show Value) §21.2.2.189
 
953
  - spPr (Shape Properties) §21.2.2.197
 
954
  - tx (Chart Text) §21.2.2.214
 
955
  - txPr (Text Properties) §21.2.2.216
 
956
 
 
957
*/
 
958
KoFilter::ConversionStatus XlsxXmlChartReader::read_dLbl()
 
959
{
 
960
    READ_PROLOGUE
 
961
      while (!atEnd()) {
 
962
          readNext();
 
963
          BREAK_IF_END_OF(CURRENT_EL);
 
964
          if (isStartElement()) {
 
965
              if ( qualifiedName() == "c:showVal" ) {
 
966
                  m_currentSeries->m_showDataValues = true;
 
967
              }
 
968
          }
 
969
      }
 
970
      READ_EPILOGUE
 
971
}
 
972
 
 
973
#undef CURRENT_EL
 
974
#define CURRENT_EL dLbls
 
975
//! dLbls (Data Labels)
 
976
/*! ECMA-376, 21.2.2.49, p.3781.
 
977
 
 
978
 Parent elements:
 
979
 - area3DChart (§21.2.2.4)
 
980
 - areaChart (§21.2.2.5)
 
981
 - bar3DChart (§21.2.2.15)
 
982
 - barChart (§21.2.2.16)
 
983
 - bubbleChart (§21.2.2.20)
 
984
 - doughnutChart (§21.2.2.50)
 
985
 - line3DChart (§21.2.2.96)
 
986
 - lineChart (§21.2.2.97)
 
987
 - ofPieChart (§21.2.2.126)
 
988
 - pie3DChart (§21.2.2.140)
 
989
 - pieChart (§21.2.2.141)
 
990
 - radarChart (§21.2.2.153)
 
991
 - scatterChart (§21.2.2.161)
 
992
 - ser (§21.2.2.168)
 
993
 - ser (§21.2.2.170)
 
994
 - ser (§21.2.2.174)
 
995
 - ser (§21.2.2.171)
 
996
 - ser (§21.2.2.172)
 
997
 - ser (§21.2.2.169)
 
998
 - ser (§21.2.2.167)
 
999
 - stockChart (§21.2.2.198)
 
1000
 
 
1001
 Child elements:
 
1002
  - delete (Delete) §21.2.2.40
 
1003
  - [Done]dLbl (Data Label) §21.2.2.47
 
1004
  - dLblPos (Data Label Position) §21.2.2.48
 
1005
  - extLst (Chart Extensibility) §21.2.2.64
 
1006
  - leaderLines (Leader Lines) §21.2.2.92
 
1007
  - numFmt (Number Format) §21.2.2.121
 
1008
  - separator (Separator) §21.2.2.166
 
1009
  - showBubbleSize (Show Bubble Size) §21.2.2.178
 
1010
  - showCatName (Show Category Name) §21.2.2.179
 
1011
  - showLeaderLines (Show Leader Lines) §21.2.2.183
 
1012
  - showLegendKey (Show Legend Key) §21.2.2.184
 
1013
  - showPercent (Show Percent) §21.2.2.187
 
1014
  - showSerName (Show Series Name) §21.2.2.188
 
1015
  - [Done]showVal (Show Value) §21.2.2.189
 
1016
  - spPr (Shape Properties) §21.2.2.197
 
1017
  - txPr (Text Properties) §21.2.2.216
 
1018
 
 
1019
*/
 
1020
KoFilter::ConversionStatus XlsxXmlChartReader::read_dLbls()
 
1021
{
 
1022
    READ_PROLOGUE
 
1023
      while (!atEnd()) {
 
1024
          readNext();
 
1025
          BREAK_IF_END_OF(CURRENT_EL);
 
1026
          if (isStartElement()) {
 
1027
              TRY_READ_IF(dLbl)
 
1028
              if ( qualifiedName() == "c:showVal" ) {
 
1029
                  m_currentSeries->m_showDataValues = true;
 
1030
              }
 
1031
          }
 
1032
      }
 
1033
      READ_EPILOGUE
 
1034
}
 
1035
 
 
1036
 
 
1037
 
 
1038
#undef CURRENT_EL
 
1039
#define CURRENT_EL spPr
 
1040
// Visual shape properties that can be applied to a shape.
 
1041
KoFilter::ConversionStatus XlsxXmlChartReader::read_spPr()
 
1042
{
 
1043
    enum State { Start, NoFill, InFill };
 
1044
    State state = Start;
 
1045
    READ_PROLOGUE
 
1046
    int level = 0;
 
1047
    bool readingGradient = false;
 
1048
    bool readingGradientStop = false;
 
1049
    Charting::Gradient* gradient = NULL;
 
1050
    Charting::Gradient::GradientStop currentStop;
 
1051
    while (!atEnd()) {
 
1052
        readNext();
 
1053
        BREAK_IF_END_OF(CURRENT_EL);
 
1054
        if(isStartElement()) ++level;
 
1055
        else if(isEndElement()) --level;
 
1056
 
 
1057
        if (qualifiedName() == "a:solidFill" || qualifiedName() == "a:pattFill" || qualifiedName() == "a:gradFill") {
 
1058
            if (level == 1)
 
1059
                state = isStartElement() ? InFill : Start;
 
1060
        } else if (qualifiedName() == "a:noFill") {
 
1061
            if (level == 1)
 
1062
                state = isStartElement() ? NoFill : Start;
 
1063
        } else if ((state == NoFill || state == InFill) && qualifiedName() == "a:srgbClr") {
 
1064
            const QXmlStreamAttributes attrs(attributes());
 
1065
            TRY_READ_ATTR_WITHOUT_NS(val)
 
1066
            if(!val.isEmpty() && !m_context->m_chart->m_areaFormat) {
 
1067
                if(!val.startsWith('#')) val.prepend('#');
 
1068
                    if ( readingGradientStop )
 
1069
                        currentStop.knownColorValue = QColor( val );
 
1070
                    else
 
1071
                        if ( m_areaContext == ChartArea )
 
1072
                            m_context->m_chart->m_areaFormat = new Charting::AreaFormat(QColor(val), QColor(), state == InFill);
 
1073
                        else
 
1074
                            m_context->m_chart->m_plotAreaFillColor = QColor( val );
 
1075
            }
 
1076
            state = Start; // job done
 
1077
        } else if ( qualifiedName() == "a:srgbClr" ) {
 
1078
            if ( isStartElement() ) {
 
1079
                const QXmlStreamAttributes attrs(attributes());
 
1080
                TRY_READ_ATTR_WITHOUT_NS(val)
 
1081
                if(!val.isEmpty() && !m_context->m_chart->m_areaFormat) {
 
1082
                    if(!val.startsWith('#')) val.prepend('#');
 
1083
                        if ( readingGradientStop )
 
1084
                            currentStop.knownColorValue = QColor( val );
 
1085
                        else
 
1086
                            if ( m_areaContext == ChartArea )
 
1087
                                m_context->m_chart->m_areaFormat = new Charting::AreaFormat(QColor(val), QColor(), state == InFill);
 
1088
                            else
 
1089
                                m_context->m_chart->m_plotAreaFillColor = QColor( val );
 
1090
                }
 
1091
            }
 
1092
        } else if ( qualifiedName() == "a:alpha" ) {
 
1093
            const QXmlStreamAttributes attrs(attributes());
 
1094
            TRY_READ_ATTR_WITHOUT_NS(val)
 
1095
                  if ( !val.isEmpty() )
 
1096
                  {
 
1097
                      if ( readingGradientStop )
 
1098
                      {
 
1099
                          currentStop.knownColorValue.setAlphaF( val.toDouble() / 100000.0 );
 
1100
                      }else
 
1101
                      {
 
1102
                          if ( m_areaContext == ChartArea ) {
 
1103
                              if (m_context->m_chart->m_areaFormat)
 
1104
                                  m_context->m_chart->m_areaFormat->m_foreground.setAlphaF( val.toDouble() / 100000.0 );
 
1105
                          } else {
 
1106
                              m_context->m_chart->m_plotAreaFillColor.setAlphaF( val.toDouble() / 100000.0 );
 
1107
                          }                      
 
1108
                      }
 
1109
                  }
 
1110
        } else if ( qualifiedName() == "a:gsLst" ) {
 
1111
            if ( isStartElement() ) {
 
1112
                readingGradient = true;
 
1113
                gradient =  new Charting::Gradient;
 
1114
            } else if ( isEndElement() ) {
 
1115
                readingGradient = false;                
 
1116
                switch ( m_areaContext ) {
 
1117
                    case( PlotArea ):
 
1118
                      m_context->m_chart->m_plotAreaFillGradient = gradient;
 
1119
                      break;
 
1120
                    case( ChartArea ):
 
1121
                      m_context->m_chart->m_fillGradient = gradient;
 
1122
                      break;
 
1123
                }
 
1124
                gradient = NULL;
 
1125
            }
 
1126
        } else if ( qualifiedName() == "a:gs" && readingGradient ) {
 
1127
            if ( isStartElement() ) {
 
1128
                readingGradientStop = true;
 
1129
                const QXmlStreamAttributes attrs(attributes());
 
1130
                TRY_READ_ATTR_WITHOUT_NS(pos)
 
1131
                if ( !pos.isEmpty() )
 
1132
                    currentStop.position = pos.toDouble() / 1000.0;
 
1133
                
 
1134
            } else if ( isEndElement() ) {
 
1135
                // append the current gradient stop                
 
1136
                gradient->gradientStops.append( currentStop );
 
1137
                readingGradientStop = false;
 
1138
                currentStop.reset();
 
1139
            }
 
1140
        } else if ( qualifiedName() == "a:schemeClr" && readingGradientStop ) {
 
1141
            if ( isStartElement() ) {
 
1142
                const QXmlStreamAttributes attrs(attributes());
 
1143
                TRY_READ_ATTR_WITHOUT_NS(val)
 
1144
                if ( !val.isEmpty() )
 
1145
                    currentStop.referenceColor = val;
 
1146
            } else if ( isEndElement() ) {
 
1147
            }
 
1148
        } else if ( qualifiedName() == "a:tint" && readingGradientStop ) {
 
1149
            const QXmlStreamAttributes attrs(attributes());
 
1150
                TRY_READ_ATTR_WITHOUT_NS(val)
 
1151
                if ( !val.isEmpty() )
 
1152
                    currentStop.tintVal = val.toDouble() / 1000.0;
 
1153
        } else if ( qualifiedName() == "a:satMod" && readingGradientStop ) {
 
1154
            const QXmlStreamAttributes attrs(attributes());
 
1155
            TRY_READ_ATTR_WITHOUT_NS(val)
 
1156
            if ( !val.isEmpty() )
 
1157
                currentStop.satVal = val.toDouble() / 1000.0;
 
1158
        }
 
1159
         else if ( qualifiedName() == "a:lin" && readingGradient ) {
 
1160
            const QXmlStreamAttributes attrs(attributes());
 
1161
            TRY_READ_ATTR_WITHOUT_NS(ang)
 
1162
            if ( !ang.isEmpty() )
 
1163
                gradient->angle = ang.toDouble() / 60000.0;
 
1164
        }
 
1165
    }
 
1166
    READ_EPILOGUE
258
1167
}
259
1168
 
260
1169
#undef CURRENT_EL
261
1170
#define CURRENT_EL pieChart
 
1171
//! pieChart (Pie Charts)
 
1172
/*! ECMA-376, 21.2.2.141, p.3826.
 
1173
 
 
1174
 Parent elements:
 
1175
 - plotArea §21.2.2.145
 
1176
 
 
1177
 Child elements:
 
1178
 - dLbls (Data Labels) §21.2.2.49
 
1179
 - extLst (Chart Extensibility) §21.2.2.64
 
1180
 - [Done]firstSliceAng (First Slice Angle) §21.2.2.68
 
1181
 - [Done] ser (Pie Chart Series) §21.2.2.172
 
1182
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1183
*/
262
1184
KoFilter::ConversionStatus XlsxXmlChartReader::read_pieChart()
263
1185
{
264
1186
    if(!m_context->m_chart->m_impl) {
265
1187
        m_context->m_chart->m_impl = new Charting::PieImpl();
266
1188
    }
267
 
    return KoFilter::OK;
268
 
}
269
 
 
 
1189
 
 
1190
    while (!atEnd()) {
 
1191
        readNext();
 
1192
        BREAK_IF_END_OF(CURRENT_EL);
 
1193
        if (isStartElement()) {
 
1194
            if (QUALIFIED_NAME_IS(ser)) {
 
1195
                TRY_READ(pieChart_Ser)
 
1196
            }
 
1197
            ELSE_TRY_READ_IF(firstSliceAng)
 
1198
        }
 
1199
    }
 
1200
 
 
1201
    qDeleteAll(d->m_seriesData);
 
1202
 
 
1203
    return KoFilter::OK;
 
1204
}
 
1205
 
 
1206
#undef CURRENT_EL
 
1207
#define CURRENT_EL pie3DChart
 
1208
//! pie3DChart (3D Pie Charts)
 
1209
/*! ECMA-376, 21.2.2.140, p.3826.
 
1210
 
 
1211
 Parent elements:
 
1212
 - plotArea §21.2.2.145
 
1213
 
 
1214
 Child elements:
 
1215
 - dLbls (Data Labels) §21.2.2.49
 
1216
 - extLst (Chart Extensibility) §21.2.2.64
 
1217
 - [Done] ser (Pie Chart Series) §21.2.2.172
 
1218
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1219
*/
 
1220
KoFilter::ConversionStatus XlsxXmlChartReader::read_pie3DChart()
 
1221
{
 
1222
    if(!m_context->m_chart->m_impl) {
 
1223
        m_context->m_chart->m_impl = new Charting::PieImpl();
 
1224
        m_context->m_chart->m_is3d = true;
 
1225
    }
 
1226
 
 
1227
    while (!atEnd()) {
 
1228
        readNext();
 
1229
        BREAK_IF_END_OF(CURRENT_EL);
 
1230
        if (isStartElement()) {
 
1231
            if (QUALIFIED_NAME_IS(ser)) {
 
1232
                TRY_READ(pieChart_Ser)
 
1233
            }
 
1234
        }
 
1235
    }
 
1236
 
 
1237
//    // if there is only one c:ser, then c:tx can be chart title
 
1238
//    if ((m_context->m_chart->m_title == "Chart Title") && (d->m_seriesData.size() == 1)) {
 
1239
//        PieSeries * tempPieSeriesData = (PieSeries *)d->m_seriesData[0];
 
1240
//        if (tempPieSeriesData->m_tx.m_strRef.m_strCache.m_cache.size() == 1) {
 
1241
//            m_context->m_chart->m_title =  tempPieSeriesData->m_tx.m_strRef.m_strCache.m_cache[0];
 
1242
//        }
 
1243
//    }
 
1244
 
 
1245
    qDeleteAll(d->m_seriesData);
 
1246
 
 
1247
    return KoFilter::OK;
 
1248
}
 
1249
 
 
1250
#undef CURRENT_EL
 
1251
#define CURRENT_EL doughnutChart
 
1252
//! doughnutChart (Doughnut Charts)
 
1253
/*! ECMA-376, 21.2.2.50, p.3782.
 
1254
 
 
1255
 Parent elements:
 
1256
 - plotArea §21.2.2.145
 
1257
 
 
1258
 Child elements:
 
1259
 - dLbls (Data Labels) §21.2.2.49
 
1260
 - extLst (Chart Extensibility) §21.2.2.64
 
1261
 - firstSliceAng (First Slice Angle) §21.2.2.68
 
1262
 - [Done]holeSize (Hole Size) §21.2.2.82
 
1263
 - [Done]ser (Pie Chart Series) §21.2.2.172
 
1264
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1265
*/
 
1266
KoFilter::ConversionStatus XlsxXmlChartReader::read_doughnutChart()
 
1267
{
 
1268
    if(!m_context->m_chart->m_impl) {
 
1269
        m_context->m_chart->m_impl = new Charting::RingImpl();
 
1270
    }
 
1271
 
 
1272
    while (!atEnd()) {
 
1273
        readNext();
 
1274
        BREAK_IF_END_OF(CURRENT_EL);
 
1275
        if (isStartElement()) {
 
1276
            if (QUALIFIED_NAME_IS(ser)) {
 
1277
                TRY_READ(pieChart_Ser)
 
1278
            }
 
1279
            ELSE_TRY_READ_IF(holeSize)
 
1280
        }
 
1281
    }
 
1282
 
 
1283
    qDeleteAll(d->m_seriesData);
 
1284
 
 
1285
    return KoFilter::OK;
 
1286
}
 
1287
 
 
1288
#undef CURRENT_EL
 
1289
#define CURRENT_EL areaChart
 
1290
//! areaChart (Area Charts)
 
1291
/*! ECMA-376, 21.2.2.5, p.3757.
 
1292
 
 
1293
 Parent elements:
 
1294
 - plotArea §21.2.2.145
 
1295
 
 
1296
 Child elements:
 
1297
 - axId (Axis ID) §21.2.2.9
 
1298
 - dLbls (Data Labels) §21.2.2.49
 
1299
 - dropLines (Drop Lines) §21.2.2.53
 
1300
 - extLst (Chart Extensibility) §21.2.2.64
 
1301
 - grouping (Grouping) §21.2.2.76
 
1302
 - [Done]ser (Area Chart Series) §21.2.2.168
 
1303
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1304
*/
 
1305
KoFilter::ConversionStatus XlsxXmlChartReader::read_areaChart()
 
1306
{
 
1307
    if(!m_context->m_chart->m_impl) {
 
1308
        m_context->m_chart->m_impl = new Charting::AreaImpl();
 
1309
    }
 
1310
 
 
1311
    while (!atEnd()) {
 
1312
        readNext();
 
1313
        BREAK_IF_END_OF(CURRENT_EL);
 
1314
        if (isStartElement()) {
 
1315
            if (QUALIFIED_NAME_IS(ser)) {
 
1316
                TRY_READ(areaChart_Ser)
 
1317
            }
 
1318
        }
 
1319
    }
 
1320
 
 
1321
    qDeleteAll(d->m_seriesData);
 
1322
 
 
1323
    return KoFilter::OK;
 
1324
}
 
1325
 
 
1326
#undef CURRENT_EL
 
1327
#define CURRENT_EL area3DChart
 
1328
//! area3DChart (3D Area Charts)
 
1329
/*! ECMA-376, 21.2.2.4, p.3757.
 
1330
 
 
1331
 Parent elements:
 
1332
 - plotArea §21.2.2.145
 
1333
 
 
1334
 Child elements:
 
1335
 - axId (Axis ID) §21.2.2.9
 
1336
 - dLbls (Data Labels) §21.2.2.49
 
1337
 - dropLines (Drop Lines) §21.2.2.53
 
1338
 - extLst (Chart Extensibility) §21.2.2.64
 
1339
 - gapDepth (Gap Depth) §21.2.2.74
 
1340
 - grouping (Grouping) §21.2.2.76
 
1341
 - [Done]ser (Area Chart Series) §21.2.2.168
 
1342
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1343
*/
 
1344
KoFilter::ConversionStatus XlsxXmlChartReader::read_area3DChart()
 
1345
{
 
1346
    if(!m_context->m_chart->m_impl) {
 
1347
        m_context->m_chart->m_impl = new Charting::AreaImpl();
 
1348
        m_context->m_chart->m_is3d = true;
 
1349
    }
 
1350
 
 
1351
    while (!atEnd()) {
 
1352
        readNext();
 
1353
        BREAK_IF_END_OF(CURRENT_EL);
 
1354
        if (isStartElement()) {
 
1355
            if (QUALIFIED_NAME_IS(ser)) {
 
1356
                TRY_READ(areaChart_Ser)
 
1357
            }
 
1358
        }
 
1359
    }
 
1360
 
 
1361
    qDeleteAll(d->m_seriesData);
 
1362
 
 
1363
    return KoFilter::OK;
 
1364
}
 
1365
 
 
1366
#undef CURRENT_EL
 
1367
#define CURRENT_EL barChart
 
1368
//! barChart (Bar Charts)
 
1369
/*! ECMA-376, 21.2.2.16, p.3863.
 
1370
 
 
1371
 Parent elements:
 
1372
 - plotArea §21.2.2.145
 
1373
 
 
1374
 Child elements:
 
1375
 - axId (Axis ID) §21.2.2.9
 
1376
 - [Done]barDir (Bar Direction) §21.2.2.17
 
1377
 - dLbls (Data Labels) §21.2.2.49
 
1378
 - extLst (Chart Extensibility) §21.2.2.64
 
1379
 - gapWidth (Gap Width) §21.2.2.75
 
1380
 - [Done]grouping (Bar Grouping) §21.2.2.77
 
1381
 - overlap (Overlap) §21.2.2.131
 
1382
 - [Done]ser (Bar Chart Series) §21.2.2.170
 
1383
 - serLines (Series Lines) §21.2.2.176
 
1384
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1385
*/
 
1386
KoFilter::ConversionStatus XlsxXmlChartReader::read_barChart()
 
1387
{
 
1388
    if(!m_context->m_chart->m_impl) {
 
1389
        m_context->m_chart->m_impl = new Charting::BarImpl();
 
1390
    }
 
1391
 
 
1392
    while (!atEnd()) {
 
1393
        readNext();
 
1394
        BREAK_IF_END_OF(CURRENT_EL);
 
1395
        if (isStartElement()) {
 
1396
            if (QUALIFIED_NAME_IS(ser)) {
 
1397
                TRY_READ(barChart_Ser)
 
1398
            }
 
1399
            ELSE_TRY_READ_IF(barDir)
 
1400
            ELSE_TRY_READ_IF(grouping)
 
1401
        }
 
1402
    }
 
1403
 
 
1404
    qDeleteAll(d->m_seriesData);
 
1405
 
 
1406
    return KoFilter::OK;
 
1407
}
 
1408
 
 
1409
#undef CURRENT_EL
 
1410
#define CURRENT_EL bar3DChart
 
1411
//! bar3DChart (3D Bar Charts)
 
1412
/*! ECMA-376, 21.2.2.15, p.3862.
 
1413
 
 
1414
 Parent elements:
 
1415
 - plotArea §21.2.2.145
 
1416
 
 
1417
 Child elements:
 
1418
 - axId (Axis ID) §21.2.2.9
 
1419
 - [done]barDir (Bar Direction) §21.2.2.17
 
1420
 - dLbls (Data Labels) §21.2.2.49
 
1421
 - extLst (Chart Extensibility) §21.2.2.64
 
1422
 - gapDepth (Gap Depth) §21.2.2.74
 
1423
 - gapWidth (Gap Width) §21.2.2.75
 
1424
 - [Done]grouping (Bar Grouping) §21.2.2.77
 
1425
 - [Done]ser (Bar Chart Series) §21.2.2.170
 
1426
 - shape (Shape) §21.2.2.177
 
1427
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1428
*/
 
1429
KoFilter::ConversionStatus XlsxXmlChartReader::read_bar3DChart()
 
1430
{
 
1431
    if(!m_context->m_chart->m_impl) {
 
1432
        m_context->m_chart->m_impl = new Charting::BarImpl();
 
1433
        m_context->m_chart->m_is3d = true;
 
1434
    }
 
1435
 
 
1436
    while (!atEnd()) {
 
1437
        readNext();
 
1438
        BREAK_IF_END_OF(CURRENT_EL);
 
1439
        if (isStartElement()) {
 
1440
            if (QUALIFIED_NAME_IS(ser)) {
 
1441
                TRY_READ(barChart_Ser)
 
1442
            }
 
1443
            ELSE_TRY_READ_IF(barDir)
 
1444
            ELSE_TRY_READ_IF(grouping)
 
1445
        }
 
1446
    }
 
1447
 
 
1448
    qDeleteAll(d->m_seriesData);
 
1449
 
 
1450
    return KoFilter::OK;
 
1451
}
 
1452
 
 
1453
#undef CURRENT_EL
 
1454
#define CURRENT_EL lineChart
 
1455
//! lineChart (Line Charts)
 
1456
/*! ECMA-376, 21.2.2.97, p.3804.
 
1457
 
 
1458
 Parent elements:
 
1459
 - plotArea §21.2.2.145
 
1460
 
 
1461
 Child elements:
 
1462
 - axId (Axis ID) §21.2.2.9
 
1463
 - dLbls (Data Labels) §21.2.2.49
 
1464
 - dropLines (Drop Lines) §21.2.2.53
 
1465
 - extLst (Chart Extensibility) §21.2.2.64
 
1466
 - [Done]grouping (Grouping) §21.2.2.76
 
1467
 - hiLowLines (High Low Lines) §21.2.2.80
 
1468
 - marker (Show Marker) §21.2.2.105
 
1469
 - [Done]ser (Line Chart Series) §21.2.2.171
 
1470
 - smooth (Smoothing) §21.2.2.194
 
1471
 - upDownBars (Up/Down Bars) §21.2.2.218
 
1472
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1473
*/
 
1474
KoFilter::ConversionStatus XlsxXmlChartReader::read_lineChart()
 
1475
{
 
1476
    if(!m_context->m_chart->m_impl) {
 
1477
        m_context->m_chart->m_impl = new Charting::LineImpl();
 
1478
    }
 
1479
 
 
1480
    while (!atEnd()) {
 
1481
        readNext();
 
1482
        BREAK_IF_END_OF(CURRENT_EL);
 
1483
        if (isStartElement()) {
 
1484
            if (QUALIFIED_NAME_IS(ser)) {
 
1485
                TRY_READ(lineChart_Ser)
 
1486
            }
 
1487
            ELSE_TRY_READ_IF(grouping)
 
1488
//             if ( qualifiedName() == "c:marker" )
 
1489
            {
 
1490
                const QXmlStreamAttributes attrs(attributes());
 
1491
                TRY_READ_ATTR_WITHOUT_NS(val);
 
1492
                if ( val == "1" || val == "true" || val == "on " )
 
1493
                {                    
 
1494
                    m_context->m_chart->m_showMarker = true;
 
1495
                }
 
1496
            }
 
1497
        }
 
1498
    }
 
1499
 
 
1500
    qDeleteAll(d->m_seriesData);
 
1501
 
 
1502
    return KoFilter::OK;
 
1503
}
 
1504
 
 
1505
#undef CURRENT_EL
 
1506
#define CURRENT_EL line3DChart
 
1507
//! line3DChart (3D Line Charts)
 
1508
/*! ECMA-376, 21.2.2.96, p.3803.
 
1509
 
 
1510
 Parent elements:
 
1511
 - plotArea §21.2.2.145
 
1512
 
 
1513
 Child elements:
 
1514
 - axId (Axis ID) §21.2.2.9
 
1515
 - dLbls (Data Labels) §21.2.2.49
 
1516
 - dropLines (Drop Lines) §21.2.2.53
 
1517
 - extLst (Chart Extensibility) §21.2.2.64
 
1518
 - gapDepth (Gap Depth) §21.2.2.74
 
1519
 - [Done]grouping (Grouping) §21.2.2.76
 
1520
 - [Done]ser (Line Chart Series) §21.2.2.171
 
1521
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1522
*/
 
1523
KoFilter::ConversionStatus XlsxXmlChartReader::read_line3DChart()
 
1524
{
 
1525
    if(!m_context->m_chart->m_impl) {
 
1526
        m_context->m_chart->m_impl = new Charting::LineImpl();
 
1527
        m_context->m_chart->m_is3d = true;
 
1528
    }
 
1529
 
 
1530
    while (!atEnd()) {
 
1531
        readNext();
 
1532
        BREAK_IF_END_OF(CURRENT_EL);
 
1533
        if (isStartElement()) {
 
1534
            if (QUALIFIED_NAME_IS(ser)) {
 
1535
                TRY_READ(lineChart_Ser)
 
1536
            }
 
1537
            ELSE_TRY_READ_IF(grouping)
 
1538
        }
 
1539
    }
 
1540
 
 
1541
    qDeleteAll(d->m_seriesData);
 
1542
 
 
1543
    return KoFilter::OK;
 
1544
}
 
1545
 
 
1546
#undef CURRENT_EL
 
1547
#define CURRENT_EL scatterChart
 
1548
//! scatterChart (Scatter Charts)
 
1549
/*! ECMA-376, 21.2.2.161, p.3836.
 
1550
 
 
1551
 Parent elements:
 
1552
 - plotArea §21.2.2.145
 
1553
 
 
1554
 Child elements:
 
1555
 - axId (Axis ID) §21.2.2.9
 
1556
 - dLbls (Data Labels) §21.2.2.49
 
1557
 - extLst (Chart Extensibility) §21.2.2.64
 
1558
 - scatterStyle (Scatter Style) §21.2.2.162
 
1559
 - [Done]ser (Scatter Chart Series) §21.2.2.167
 
1560
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1561
*/
 
1562
KoFilter::ConversionStatus XlsxXmlChartReader::read_scatterChart()
 
1563
{
 
1564
    if(!m_context->m_chart->m_impl) {
 
1565
        m_context->m_chart->m_impl = new Charting::ScatterImpl();
 
1566
    }
 
1567
 
 
1568
    while (!atEnd()) {
 
1569
        readNext();
 
1570
        BREAK_IF_END_OF(CURRENT_EL);
 
1571
        if (isStartElement()) {
 
1572
            if (QUALIFIED_NAME_IS(ser)) {
 
1573
                TRY_READ(scatterChart_Ser)
 
1574
            }
 
1575
        }
 
1576
    }
 
1577
 
 
1578
    qDeleteAll(d->m_seriesData);
 
1579
 
 
1580
    return KoFilter::OK;
 
1581
}
 
1582
 
 
1583
#undef CURRENT_EL
 
1584
#define CURRENT_EL radarChart
 
1585
//! radarChart (Radar Charts)
 
1586
/*! ECMA-376, 21.2.2.153, p.3832.
 
1587
 
 
1588
 Parent elements:
 
1589
 - plotArea §21.2.2.145
 
1590
 
 
1591
 Child elements:
 
1592
 - axId (Axis ID) §21.2.2.9
 
1593
 - dLbls (Data Labels) §21.2.2.49
 
1594
 - extLst (Chart Extensibility) §21.2.2.64
 
1595
 - radarStyle (Radar Style) §21.2.2.154
 
1596
 - [Done]ser (Radar Chart Series) §21.2.2.169
 
1597
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1598
*/
 
1599
KoFilter::ConversionStatus XlsxXmlChartReader::read_radarChart()
 
1600
{
 
1601
    if(!m_context->m_chart->m_impl) {
 
1602
        m_context->m_chart->m_impl = new Charting::RadarImpl();
 
1603
    }
 
1604
 
 
1605
    while (!atEnd()) {
 
1606
        readNext();
 
1607
        BREAK_IF_END_OF(CURRENT_EL);
 
1608
        if (isStartElement()) {
 
1609
            if (QUALIFIED_NAME_IS(ser)) {
 
1610
                TRY_READ(radarChart_Ser)
 
1611
            }
 
1612
        }
 
1613
    }
 
1614
 
 
1615
    qDeleteAll(d->m_seriesData);
 
1616
 
 
1617
    return KoFilter::OK;
 
1618
}
 
1619
 
 
1620
#undef CURRENT_EL
 
1621
#define CURRENT_EL surfaceChart
 
1622
//! surface3DChart (3D Surface Charts)
 
1623
/*! ECMA-376, 21.2.2.203, p.3858.
 
1624
 
 
1625
 Parent elements:
 
1626
 - plotArea §21.2.2.145
 
1627
 
 
1628
 Child elements:
 
1629
 - axId (Axis ID) §21.2.2.9
 
1630
 - bandFmts (Band Formats) §21.2.2.14
 
1631
 - extLst (Chart Extensibility) §21.2.2.64
 
1632
 - [Done]ser (Surface Chart Series) §21.2.2.173
 
1633
 - wireframe (Wireframe) §21.2.2.230
 
1634
*/
 
1635
KoFilter::ConversionStatus XlsxXmlChartReader::read_surfaceChart()
 
1636
{
 
1637
    if(!m_context->m_chart->m_impl) {
 
1638
        m_context->m_chart->m_impl = new Charting::SurfaceImpl();
 
1639
    }
 
1640
 
 
1641
    while (!atEnd()) {
 
1642
        readNext();
 
1643
        BREAK_IF_END_OF(CURRENT_EL);
 
1644
        if (isStartElement()) {
 
1645
            if (QUALIFIED_NAME_IS(ser)) {
 
1646
                TRY_READ(surfaceChart_Ser)
 
1647
            }
 
1648
        }
 
1649
    }
 
1650
 
 
1651
    qDeleteAll(d->m_seriesData);
 
1652
 
 
1653
    return KoFilter::OK;
 
1654
}
 
1655
 
 
1656
#undef CURRENT_EL
 
1657
#define CURRENT_EL surface3DChart
 
1658
//! surfaceChart (Surface Charts)
 
1659
/*! ECMA-376, 21.2.2.204, p.3858.
 
1660
 
 
1661
 Parent elements:
 
1662
 - plotArea §21.2.2.145
 
1663
 
 
1664
 Child elements:
 
1665
 - axId (Axis ID) §21.2.2.9
 
1666
 - bandFmts (Band Formats) §21.2.2.14
 
1667
 - extLst (Chart Extensibility) §21.2.2.64
 
1668
 - ser (Surface Chart Series) §21.2.2.173
 
1669
 - wireframe (Wireframe) §21.2.2.230
 
1670
*/
 
1671
KoFilter::ConversionStatus XlsxXmlChartReader::read_surface3DChart()
 
1672
{
 
1673
    if(!m_context->m_chart->m_impl) {
 
1674
        m_context->m_chart->m_impl = new Charting::SurfaceImpl();
 
1675
        m_context->m_chart->m_is3d = true;
 
1676
    }
 
1677
 
 
1678
    while (!atEnd()) {
 
1679
        readNext();
 
1680
        BREAK_IF_END_OF(CURRENT_EL);
 
1681
        if (isStartElement()) {
 
1682
            if (QUALIFIED_NAME_IS(ser)) {
 
1683
                TRY_READ(surfaceChart_Ser)
 
1684
            }
 
1685
        }
 
1686
    }
 
1687
 
 
1688
    qDeleteAll(d->m_seriesData);
 
1689
 
 
1690
    return KoFilter::OK;
 
1691
}
 
1692
 
 
1693
#undef CURRENT_EL
 
1694
#define CURRENT_EL bubbleChart
 
1695
//! bubbleChart (Bubble Charts)
 
1696
/*! ECMA-376, 21.2.2.20, p.3765.
 
1697
 
 
1698
 Parent elements:
 
1699
 - plotArea §21.2.2.145
 
1700
 
 
1701
 Child elements:
 
1702
 - axId (Axis ID) §21.2.2.9
 
1703
 - [Done]bubble3D (3D Bubble) §21.2.2.19
 
1704
 - [Done]bubbleScale (Bubble Scale) §21.2.2.21
 
1705
 - dLbls (Data Labels) §21.2.2.49
 
1706
 - extLst (Chart Extensibility) §21.2.2.64
 
1707
 - [Done]ser (Bubble Chart Series) §21.2.2.174
 
1708
 - showNegBubbles (Show Negative Bubbles) §21.2.2.185
 
1709
 - sizeRepresents (Size Represents) §21.2.2.193
 
1710
 - varyColors (Vary Colors by Point) §21.2.2.227
 
1711
*/
 
1712
KoFilter::ConversionStatus XlsxXmlChartReader::read_bubbleChart()
 
1713
{
 
1714
    if(!m_context->m_chart->m_impl) {
 
1715
        m_context->m_chart->m_impl = new Charting::BubbleImpl();
 
1716
        m_context->m_chart->m_is3d = true;
 
1717
    }
 
1718
 
 
1719
    while (!atEnd()) {
 
1720
        readNext();
 
1721
        BREAK_IF_END_OF(CURRENT_EL);
 
1722
        if (isStartElement()) {
 
1723
            if (QUALIFIED_NAME_IS(ser)) {
 
1724
                TRY_READ(bubbleChart_Ser)
 
1725
            }
 
1726
            ELSE_TRY_READ_IF(bubbleScale)
 
1727
            ELSE_TRY_READ_IF(bubble3D)
 
1728
        }
 
1729
    }
 
1730
 
 
1731
    // check if there are some c:strLit or c:numLit data and if yes then write them into internalTable
 
1732
//    for (int i=0; i<d->m_seriesData.size(); i++ ){
 
1733
//        QString range = ((BubbleSeries *)d->m_seriesData[i])->m_bubbleSize.writeLitToInternalTable(this);
 
1734
//        if (!range.isEmpty()) {
 
1735
//            m_context->m_chart->m_series[i]->m_domainValuesCellRangeAddress.push_back(range);
 
1736
//        }
 
1737
//    }
 
1738
 
 
1739
    qDeleteAll(d->m_seriesData);
 
1740
 
 
1741
    return KoFilter::OK;
 
1742
}
 
1743
 
 
1744
#undef CURRENT_EL
 
1745
#define CURRENT_EL stockChart
 
1746
//! stockChart (Stock Charts)
 
1747
/*! ECMA-376, 21.2.2.199, p.3856.
 
1748
 
 
1749
 Parent elements:
 
1750
 - plotArea §21.2.2.145
 
1751
 
 
1752
 Child elements:
 
1753
 - axId (Axis ID) §21.2.2.9
 
1754
 - dLbls (Data Labels) §21.2.2.49
 
1755
 - dropLines (Drop Lines) §21.2.2.53
 
1756
 - extLst (Chart Extensibility) §21.2.2.64
 
1757
 - hiLowLines (High Low Lines) §21.2.2.80
 
1758
 - [done]ser (Line Chart Series) §21.2.2.171
 
1759
 - upDownBars (Up/Down Bars) §21.2.2.218
 
1760
*/
 
1761
KoFilter::ConversionStatus XlsxXmlChartReader::read_stockChart()
 
1762
{
 
1763
    if(!m_context->m_chart->m_impl) {
 
1764
        m_context->m_chart->m_impl = new Charting::StockImpl();
 
1765
    }
 
1766
 
 
1767
    while (!atEnd()) {
 
1768
        readNext();
 
1769
        BREAK_IF_END_OF(CURRENT_EL);
 
1770
        if (isStartElement()) {
 
1771
            if (QUALIFIED_NAME_IS(ser)) {
 
1772
                TRY_READ(lineChart_Ser)
 
1773
            }
 
1774
        }
 
1775
    }
 
1776
 
 
1777
    qDeleteAll(d->m_seriesData);
 
1778
 
 
1779
    return KoFilter::OK;
 
1780
}
 
1781
 
 
1782
#undef CURRENT_EL
 
1783
#define CURRENT_EL ser
 
1784
//! ser (Pie Chart Series)
 
1785
/*! ECMA-376, 21.2.2.172, p.3842.
 
1786
 
 
1787
 Parent elements:
 
1788
 - doughnutChart §21.2.2.50
 
1789
 - ofPieChart §21.2.2.126
 
1790
 - pie3DChart §21.2.2.140
 
1791
 - pieChart §21.2.2.141
 
1792
 
 
1793
 Child elements:
 
1794
 - cat (Category Axis Data) §21.2.2.24
 
1795
 - [Done]dLbls (Data Labels) §21.2.2.49
 
1796
 - dPt (Data Point) §21.2.2.52
 
1797
 - explosion (Explosion) §21.2.2.61
 
1798
 - extLst (Chart Extensibility) §21.2.2.64
 
1799
 - [Done]idx (Index) §21.2.2.84
 
1800
 - [Done] order (Order) §21.2.2.128
 
1801
 - spPr (Shape Properties) §21.2.2.197
 
1802
 - tx (Series Text) §21.2.2.215
 
1803
 - val (Values) §21.2.2.224
 
1804
 
 
1805
*/
 
1806
 
 
1807
KoFilter::ConversionStatus XlsxXmlChartReader::read_pieChart_Ser()
 
1808
{
 
1809
    READ_PROLOGUE2(pieChart_Ser)
 
1810
 
 
1811
    m_currentSeries  = new Charting::Series();
 
1812
    m_context->m_chart->m_series << m_currentSeries;
 
1813
 
 
1814
    PieSeries * tempPieSeriesData = new PieSeries();
 
1815
    d->m_seriesData << tempPieSeriesData;
 
1816
 
 
1817
    d->m_currentIdx = &tempPieSeriesData->m_idx;
 
1818
    d->m_currentOrder = &tempPieSeriesData->m_order;
 
1819
    d->m_currentTx = &tempPieSeriesData->m_tx;
 
1820
    d->m_currentCat = &tempPieSeriesData->m_cat;
 
1821
    d->m_currentVal = &tempPieSeriesData->m_val;
 
1822
    d->m_currentExplosion = &tempPieSeriesData->m_explosion;
 
1823
 
 
1824
    while (!atEnd()) {
 
1825
        readNext();
 
1826
        BREAK_IF_END_OF(CURRENT_EL);
 
1827
        if (isStartElement()) {
 
1828
            TRY_READ_IF(order)
 
1829
            ELSE_TRY_READ_IF(idx)
 
1830
            if (QUALIFIED_NAME_IS(tx)) {
 
1831
                TRY_READ(seriesText_Tx)
 
1832
            }
 
1833
            ELSE_TRY_READ_IF(cat)
 
1834
            ELSE_TRY_READ_IF(val)
 
1835
            ELSE_TRY_READ_IF(explosion)
 
1836
            ELSE_TRY_READ_IF(dLbls)
 
1837
        }
 
1838
    }
 
1839
 
 
1840
    // set data ranges and write data to internal table
 
1841
    m_currentSeries->m_countYValues = tempPieSeriesData->m_val.m_numRef.m_numCache.m_ptCount;
 
1842
 
 
1843
    m_currentSeries->m_labelCell = tempPieSeriesData->m_tx.writeRefToInternalTable(this);
 
1844
 
 
1845
    m_currentSeries->m_valuesCellRangeAddress = tempPieSeriesData->m_val.writeRefToInternalTable(this);
 
1846
 
 
1847
    m_context->m_chart->m_verticalCellRangeAddress = tempPieSeriesData->m_cat.writeRefToInternalTable(this);
 
1848
 
 
1849
    // set explosion
 
1850
    if (tempPieSeriesData->m_explosion != 0) {
 
1851
        if(Charting::PieImpl* pie = dynamic_cast<Charting::PieImpl*>(m_context->m_chart->m_impl)) {
 
1852
            Q_UNUSED(pie);
 
1853
            m_currentSeries->m_datasetFormat << new Charting::PieFormat(tempPieSeriesData->m_explosion);
 
1854
        }
 
1855
    }
 
1856
 
 
1857
    READ_EPILOGUE
 
1858
}
 
1859
 
 
1860
#undef CURRENT_EL
 
1861
#define CURRENT_EL ser
 
1862
//! ser (Bubble Chart Series)
 
1863
/*! ECMA-376, 21.2.2.174, p.3843.
 
1864
 
 
1865
 Parent elements:
 
1866
  - ser (Bubble Chart Series)
 
1867
 
 
1868
 Child elements:
 
1869
 - [Done]bubble3D (3D Bubble) §21.2.2.19
 
1870
 - [Done]bubbleSize (Bubble Size) §21.2.2.22
 
1871
 - [Done]dLbls (Data Labels) §21.2.2.49
 
1872
 - dPt (Data Point) §21.2.2.52
 
1873
 - errBars (Error Bars) §21.2.2.55
 
1874
 - extLst (Chart Extensibility) §21.2.2.64
 
1875
 - [Done]idx (Index) §21.2.2.84
 
1876
 - invertIfNegative (Invert if Negative) §21.2.2.86
 
1877
 - [Done]order (Order) §21.2.2.128
 
1878
 - spPr (Shape Properties) §21.2.2.197
 
1879
 - trendline (Trendlines) §21.2.2.211
 
1880
 - [Done]tx (Series Text) §21.2.2.215
 
1881
 - [Done]xVal (X Values) §21.2.2.234
 
1882
 - [Done]yVal (Y Values) §21.2.2.237
 
1883
 
 
1884
*/
 
1885
 
 
1886
KoFilter::ConversionStatus XlsxXmlChartReader::read_bubbleChart_Ser()
 
1887
{
 
1888
    READ_PROLOGUE2(bubbleChart_Ser)
 
1889
 
 
1890
    m_currentSeries  = new Charting::Series();
 
1891
    m_context->m_chart->m_series << m_currentSeries;
 
1892
 
 
1893
    BubbleSeries * tempBubbleSeriesData = new BubbleSeries();
 
1894
    d->m_seriesData << tempBubbleSeriesData;
 
1895
 
 
1896
    d->m_currentIdx = &tempBubbleSeriesData->m_idx;
 
1897
    d->m_currentOrder = &tempBubbleSeriesData->m_order;
 
1898
    d->m_currentTx = &tempBubbleSeriesData->m_tx;
 
1899
    d->m_currentXVal = &tempBubbleSeriesData->m_xVal;
 
1900
    d->m_currentYVal = &tempBubbleSeriesData->m_yVal;
 
1901
    d->m_currentBubbleSize = &tempBubbleSeriesData->m_bubbleSize;
 
1902
 
 
1903
    while (!atEnd()) {
 
1904
        readNext();
 
1905
        BREAK_IF_END_OF(CURRENT_EL);
 
1906
        if (isStartElement()) {
 
1907
            TRY_READ_IF(order)
 
1908
            ELSE_TRY_READ_IF(idx)
 
1909
            if (QUALIFIED_NAME_IS(tx)) {
 
1910
                TRY_READ(seriesText_Tx)
 
1911
            }
 
1912
            ELSE_TRY_READ_IF(xVal)
 
1913
            ELSE_TRY_READ_IF(yVal)
 
1914
            ELSE_TRY_READ_IF(bubbleSize)
 
1915
            ELSE_TRY_READ_IF(dLbls)
 
1916
            ELSE_TRY_READ_IF(bubble3D)
 
1917
        }
 
1918
    }
 
1919
 
 
1920
    // set data ranges and write data to internal table
 
1921
    m_currentSeries->m_labelCell = tempBubbleSeriesData->m_tx.writeRefToInternalTable(this);
 
1922
 
 
1923
    m_currentSeries->m_countYValues = tempBubbleSeriesData->m_yVal.m_numRef.m_numCache.m_ptCount;    
 
1924
 
 
1925
    m_currentSeries->m_domainValuesCellRangeAddress << tempBubbleSeriesData->m_yVal.writeRefToInternalTable(this);
 
1926
    
 
1927
    if ( tempBubbleSeriesData->m_bubbleSize.m_numRef.m_f.isEmpty() )
 
1928
        m_currentSeries->m_valuesCellRangeAddress = tempBubbleSeriesData->m_bubbleSize.writeLitToInternalTable(this);
 
1929
    else
 
1930
        m_currentSeries->m_valuesCellRangeAddress = tempBubbleSeriesData->m_bubbleSize.writeRefToInternalTable(this);
 
1931
    
 
1932
 
 
1933
//    m_currentSeries->m_domainValuesCellRangeAddress.push_back(tempBubbleSeriesData->m_xVal.writeRefToInternalTable(this));
 
1934
//
 
1935
//    QString bubbleSizeRange = tempBubbleSeriesData->m_bubbleSize.writeRefToInternalTable(this);
 
1936
//    if (!bubbleSizeRange.isEmpty()) {
 
1937
//        m_currentSeries->m_domainValuesCellRangeAddress.push_back(tempBubbleSeriesData->m_bubbleSize.writeRefToInternalTable(this));
 
1938
//    }
 
1939
 
 
1940
    READ_EPILOGUE
 
1941
}
 
1942
 
 
1943
#undef CURRENT_EL
 
1944
#define CURRENT_EL ser
 
1945
//! ser (Scatter Chart Series)
 
1946
/*! ECMA-376, 21.2.2.167, p.3838.
 
1947
 
 
1948
 Parent elements:
 
1949
  - scatterChart (§21.2.2.161)
 
1950
 
 
1951
 Child elements:
 
1952
 - [Done]dLbls (Data Labels) §21.2.2.49
 
1953
 - dPt (Data Point) §21.2.2.52
 
1954
 - errBars (Error Bars) §21.2.2.55
 
1955
 - extLst (Chart Extensibility) §21.2.2.64
 
1956
 - [done]idx (Index) §21.2.2.84
 
1957
 - marker (Marker) §21.2.2.106
 
1958
 - [Done]order (Order) §21.2.2.128
 
1959
 - smooth (Smoothing) §21.2.2.194
 
1960
 - spPr (Shape Properties) §21.2.2.197
 
1961
 - trendline (Trendlines) §21.2.2.211
 
1962
 - [Done]tx (Series Text) §21.2.2.215
 
1963
 - [Done]xVal (X Values) §21.2.2.234
 
1964
 - [Done]yVal (Y Values) §21.2.2.237
 
1965
*/
 
1966
 
 
1967
KoFilter::ConversionStatus XlsxXmlChartReader::read_scatterChart_Ser()
 
1968
{
 
1969
    READ_PROLOGUE2(scatterChart_Ser)
 
1970
 
 
1971
    m_currentSeries  = new Charting::Series();
 
1972
    m_context->m_chart->m_series << m_currentSeries;
 
1973
 
 
1974
    ScatterSeries * tempScatterSeriesData = new ScatterSeries();
 
1975
    d->m_seriesData << tempScatterSeriesData;
 
1976
 
 
1977
    d->m_currentIdx = &tempScatterSeriesData->m_idx;
 
1978
    d->m_currentOrder = &tempScatterSeriesData->m_order;
 
1979
    d->m_currentTx = &tempScatterSeriesData->m_tx;
 
1980
    d->m_currentXVal = &tempScatterSeriesData->m_xVal;
 
1981
    d->m_currentYVal = &tempScatterSeriesData->m_yVal;
 
1982
 
 
1983
    while (!atEnd()) {
 
1984
        readNext();
 
1985
        BREAK_IF_END_OF(CURRENT_EL);
 
1986
        if (isStartElement()) {
 
1987
            TRY_READ_IF(order)
 
1988
            ELSE_TRY_READ_IF(idx)
 
1989
            if (QUALIFIED_NAME_IS(tx)) {
 
1990
                TRY_READ(seriesText_Tx)
 
1991
            }
 
1992
            ELSE_TRY_READ_IF(xVal)
 
1993
            ELSE_TRY_READ_IF(yVal)
 
1994
            ELSE_TRY_READ_IF(dLbls)
 
1995
//            ELSE_TRY_READ_IF(spPr)
 
1996
        }
 
1997
    }
 
1998
 
 
1999
    // set data ranges and write data to internal table
 
2000
    m_currentSeries->m_labelCell = tempScatterSeriesData->m_tx.writeRefToInternalTable(this);
 
2001
 
 
2002
    m_currentSeries->m_countYValues = tempScatterSeriesData->m_yVal.m_numRef.m_numCache.m_ptCount;
 
2003
 
 
2004
    m_currentSeries->m_valuesCellRangeAddress = tempScatterSeriesData->m_yVal.writeRefToInternalTable(this);
 
2005
 
 
2006
    //m_currentSeries->m_domainValuesCellRangeAddress.push_back(tempScatterSeriesData->m_xVal.writeRefToInternalTable(this));
 
2007
 
 
2008
    READ_EPILOGUE
 
2009
}
 
2010
 
 
2011
#undef CURRENT_EL
 
2012
#define CURRENT_EL ser
 
2013
//! ser (Bar Chart Series)
 
2014
/*! ECMA-376, 21.2.2.167, p.3840.
 
2015
 
 
2016
 Parent elements:
 
2017
  - bar3DChart (§21.2.2.15)
 
2018
  - barChart (§21.2.2.16)
 
2019
 
 
2020
 Child elements:
 
2021
  - [Done]cat (Category Axis Data) §21.2.2.24
 
2022
  - [Done]dLbls (Data Labels) §21.2.2.49
 
2023
  - dPt (Data Point) §21.2.2.52
 
2024
  - errBars (Error Bars) §21.2.2.55
 
2025
  - extLst (Chart Extensibility) §21.2.2.64
 
2026
  - idx (Index) §21.2.2.84
 
2027
  - invertIfNegative (Invert if Negative) §21.2.2.86
 
2028
  - order (Order) §21.2.2.128
 
2029
  - pictureOptions (Picture Options) §21.2.2.138
 
2030
  - shape (Shape) §21.2.2.177
 
2031
  - spPr (Shape Properties) §21.2.2.197
 
2032
  - trendline (Trendlines) §21.2.2.211
 
2033
  - [Done]tx (Series Text) §21.2.2.215
 
2034
  - [Done]val (Values) §21.2.2.224
 
2035
*/
 
2036
 
 
2037
KoFilter::ConversionStatus XlsxXmlChartReader::read_barChart_Ser()
 
2038
{
 
2039
    READ_PROLOGUE2(barChart_Ser)
 
2040
 
 
2041
    m_currentSeries  = new Charting::Series();
 
2042
    m_context->m_chart->m_series << m_currentSeries;
 
2043
 
 
2044
    BarSeries * tempBarSeriesData = new BarSeries();
 
2045
    d->m_seriesData << tempBarSeriesData;
 
2046
 
 
2047
    d->m_currentIdx = &tempBarSeriesData->m_idx;
 
2048
    d->m_currentOrder = &tempBarSeriesData->m_order;
 
2049
    d->m_currentTx = &tempBarSeriesData->m_tx;
 
2050
    d->m_currentCat = &tempBarSeriesData->m_cat;
 
2051
    d->m_currentVal = &tempBarSeriesData->m_val;
 
2052
 
 
2053
    while (!atEnd()) {
 
2054
        readNext();
 
2055
        BREAK_IF_END_OF(CURRENT_EL);
 
2056
        if (isStartElement()) {
 
2057
            TRY_READ_IF(order)
 
2058
            ELSE_TRY_READ_IF(idx)
 
2059
            if (QUALIFIED_NAME_IS(tx)) {
 
2060
                TRY_READ(seriesText_Tx)
 
2061
            }
 
2062
            ELSE_TRY_READ_IF(cat)
 
2063
            ELSE_TRY_READ_IF(val)
 
2064
            ELSE_TRY_READ_IF(dLbls)
 
2065
        }
 
2066
    }
 
2067
 
 
2068
    // set data ranges and write data to internal table
 
2069
    m_currentSeries->m_countYValues = tempBarSeriesData->m_val.m_numRef.m_numCache.m_ptCount;
 
2070
 
 
2071
    m_currentSeries->m_labelCell = tempBarSeriesData->m_tx.writeRefToInternalTable(this);
 
2072
 
 
2073
    m_currentSeries->m_valuesCellRangeAddress = tempBarSeriesData->m_val.writeRefToInternalTable(this);
 
2074
 
 
2075
    m_context->m_chart->m_verticalCellRangeAddress = tempBarSeriesData->m_cat.writeRefToInternalTable(this);
 
2076
 
 
2077
    READ_EPILOGUE
 
2078
}
 
2079
 
 
2080
#undef CURRENT_EL
 
2081
#define CURRENT_EL ser
 
2082
//! ser (Area Chart Series)
 
2083
/*! ECMA-376, 21.2.2.168, p.3839.
 
2084
 
 
2085
 Parent elements:
 
2086
  - area3DChart (§21.2.2.4)
 
2087
  - areaChart (§21.2.2.5)
 
2088
 
 
2089
 Child elements:
 
2090
  - cat (Category Axis Data) §21.2.2.24
 
2091
  - [Done]dLbls (Data Labels) §21.2.2.49
 
2092
  - dPt (Data Point) §21.2.2.52
 
2093
  - errBars (Error Bars) §21.2.2.55
 
2094
  - extLst (Chart Extensibility) §21.2.2.64
 
2095
  - idx (Index) §21.2.2.84
 
2096
  - order (Order) §21.2.2.128
 
2097
  - pictureOptions (Picture Options) §21.2.2.138
 
2098
  - spPr (Shape Properties) §21.2.2.197
 
2099
  - trendline (Trendlines) §21.2.2.211
 
2100
  - tx (Series Text) §21.2.2.215
 
2101
  - val (Values) §21.2.2.224
 
2102
*/
 
2103
 
 
2104
KoFilter::ConversionStatus XlsxXmlChartReader::read_areaChart_Ser()
 
2105
{
 
2106
    READ_PROLOGUE2(areaChart_Ser)
 
2107
 
 
2108
    m_currentSeries  = new Charting::Series();
 
2109
    m_context->m_chart->m_series << m_currentSeries;
 
2110
 
 
2111
    AreaSeries * tempAreaSeriesData = new AreaSeries();
 
2112
    d->m_seriesData << tempAreaSeriesData;
 
2113
 
 
2114
    d->m_currentIdx = &tempAreaSeriesData->m_idx;
 
2115
    d->m_currentOrder = &tempAreaSeriesData->m_order;
 
2116
    d->m_currentTx = &tempAreaSeriesData->m_tx;
 
2117
    d->m_currentCat = &tempAreaSeriesData->m_cat;
 
2118
    d->m_currentVal = &tempAreaSeriesData->m_val;
 
2119
 
 
2120
    while (!atEnd()) {
 
2121
        readNext();
 
2122
        BREAK_IF_END_OF(CURRENT_EL);
 
2123
        if (isStartElement()) {
 
2124
            TRY_READ_IF(order)
 
2125
            ELSE_TRY_READ_IF(idx)
 
2126
            if (QUALIFIED_NAME_IS(tx)) {
 
2127
                TRY_READ(seriesText_Tx)
 
2128
            }
 
2129
            ELSE_TRY_READ_IF(cat)
 
2130
            ELSE_TRY_READ_IF(val)
 
2131
            ELSE_TRY_READ_IF(dLbls)
 
2132
        }
 
2133
    }
 
2134
 
 
2135
    // set data ranges and write data to internal table
 
2136
    m_currentSeries->m_countYValues = tempAreaSeriesData->m_val.m_numRef.m_numCache.m_ptCount;
 
2137
 
 
2138
    m_currentSeries->m_labelCell = tempAreaSeriesData->m_tx.writeRefToInternalTable(this);
 
2139
 
 
2140
    m_currentSeries->m_valuesCellRangeAddress = tempAreaSeriesData->m_val.writeRefToInternalTable(this);
 
2141
 
 
2142
    m_context->m_chart->m_verticalCellRangeAddress = tempAreaSeriesData->m_cat.writeRefToInternalTable(this);
 
2143
 
 
2144
    READ_EPILOGUE
 
2145
}
 
2146
 
 
2147
#undef CURRENT_EL
 
2148
#define CURRENT_EL ser
 
2149
//! ser (Radar Chart Series)
 
2150
/*! ECMA-376, 21.2.2.169, p.3840.
 
2151
 
 
2152
 Parent elements:
 
2153
  - radarChart (§21.2.2.153)
 
2154
 
 
2155
 Child elements:
 
2156
  - [Done]cat (Category Axis Data) §21.2.2.24
 
2157
  - [Done]dLbls (Data Labels) §21.2.2.49
 
2158
  - dPt (Data Point) §21.2.2.52
 
2159
  - extLst (Chart Extensibility) §21.2.2.64
 
2160
  - [Done]idx (Index) §21.2.2.84
 
2161
  - marker (Marker) §21.2.2.106
 
2162
  - [Done]order (Order) §21.2.2.128
 
2163
  - spPr (Shape Properties) §21.2.2.197
 
2164
  - [Done]tx (Series Text) §21.2.2.215
 
2165
  - [Done]val (Values) §21.2.2.224
 
2166
*/
 
2167
 
 
2168
KoFilter::ConversionStatus XlsxXmlChartReader::read_radarChart_Ser()
 
2169
{
 
2170
    READ_PROLOGUE2(radarChart_Ser)
 
2171
 
 
2172
    m_currentSeries  = new Charting::Series();
 
2173
    m_context->m_chart->m_series << m_currentSeries;
 
2174
 
 
2175
    RadarSeries * tempRadarSeriesData = new RadarSeries();
 
2176
    d->m_seriesData << tempRadarSeriesData;
 
2177
 
 
2178
    d->m_currentIdx = &tempRadarSeriesData->m_idx;
 
2179
    d->m_currentOrder = &tempRadarSeriesData->m_order;
 
2180
    d->m_currentTx = &tempRadarSeriesData->m_tx;
 
2181
    d->m_currentCat = &tempRadarSeriesData->m_cat;
 
2182
    d->m_currentVal = &tempRadarSeriesData->m_val;
 
2183
 
 
2184
    while (!atEnd()) {
 
2185
        readNext();
 
2186
        BREAK_IF_END_OF(CURRENT_EL);
 
2187
        if (isStartElement()) {
 
2188
            TRY_READ_IF(order)
 
2189
            ELSE_TRY_READ_IF(idx)
 
2190
            if (QUALIFIED_NAME_IS(tx)) {
 
2191
                TRY_READ(seriesText_Tx)
 
2192
            }
 
2193
            ELSE_TRY_READ_IF(cat)
 
2194
            ELSE_TRY_READ_IF(val)
 
2195
            ELSE_TRY_READ_IF(dLbls)
 
2196
        }
 
2197
    }
 
2198
 
 
2199
    // set data ranges and write data to internal table
 
2200
    m_currentSeries->m_countYValues = tempRadarSeriesData->m_val.m_numRef.m_numCache.m_ptCount;
 
2201
 
 
2202
    m_currentSeries->m_labelCell = tempRadarSeriesData->m_tx.writeRefToInternalTable(this);
 
2203
 
 
2204
    m_currentSeries->m_valuesCellRangeAddress = tempRadarSeriesData->m_val.writeRefToInternalTable(this);
 
2205
 
 
2206
    m_context->m_chart->m_verticalCellRangeAddress = tempRadarSeriesData->m_cat.writeRefToInternalTable(this);
 
2207
 
 
2208
    READ_EPILOGUE
 
2209
}
 
2210
 
 
2211
#undef CURRENT_EL
 
2212
#define CURRENT_EL ser
 
2213
//! ser (Line Chart Series)
 
2214
/*! ECMA-376, 21.2.2.168, p.3839.
 
2215
 
 
2216
 Parent elements:
 
2217
  - line3DChart (§21.2.2.96)
 
2218
  - lineChart (§21.2.2.97)
 
2219
  - stockChart (§21.2.2.198)
 
2220
 
 
2221
 Child elements:
 
2222
  - [Done]cat (Category Axis Data) §21.2.2.24
 
2223
  - [Done]dLbls (Data Labels) §21.2.2.49
 
2224
  - dPt (Data Point) §21.2.2.52
 
2225
  - errBars (Error Bars) §21.2.2.55
 
2226
  - extLst (Chart Extensibility) §21.2.2.64
 
2227
  - [Done]idx (Index) §21.2.2.84
 
2228
  - marker (Marker) §21.2.2.106
 
2229
  - [Done]order (Order) §21.2.2.128
 
2230
  - smooth (Smoothing) §21.2.2.194
 
2231
  - spPr (Shape Properties) §21.2.2.197
 
2232
  - trendline (Trendlines) §21.2.2.211
 
2233
  - [Done]tx (Series Text) §21.2.2.215
 
2234
  - [Done]val (Values) §21.2.2.224
 
2235
*/
 
2236
 
 
2237
KoFilter::ConversionStatus XlsxXmlChartReader::read_lineChart_Ser()
 
2238
{
 
2239
    READ_PROLOGUE2(lineChart_Ser)
 
2240
 
 
2241
    m_currentSeries  = new Charting::Series();
 
2242
    m_context->m_chart->m_series << m_currentSeries;
 
2243
 
 
2244
    LineSeries * tempLineSeriesData = new LineSeries();
 
2245
    d->m_seriesData << tempLineSeriesData;
 
2246
 
 
2247
    d->m_currentIdx = &tempLineSeriesData->m_idx;
 
2248
    d->m_currentOrder = &tempLineSeriesData->m_order;
 
2249
    d->m_currentTx = &tempLineSeriesData->m_tx;
 
2250
    d->m_currentCat = &tempLineSeriesData->m_cat;
 
2251
    d->m_currentVal = &tempLineSeriesData->m_val;
 
2252
 
 
2253
    while (!atEnd()) {
 
2254
        readNext();
 
2255
        BREAK_IF_END_OF(CURRENT_EL);
 
2256
        if (isStartElement()) {
 
2257
            TRY_READ_IF(order)
 
2258
            ELSE_TRY_READ_IF(idx)
 
2259
            if (QUALIFIED_NAME_IS(tx)) {
 
2260
                TRY_READ(seriesText_Tx)
 
2261
            }
 
2262
            ELSE_TRY_READ_IF(cat)
 
2263
            ELSE_TRY_READ_IF(val)
 
2264
            ELSE_TRY_READ_IF(dLbls)
 
2265
            ELSE_TRY_READ_IF(serMarker)
 
2266
//             if ( qualifiedName() == "c:marker" )
 
2267
//             {
 
2268
//                 const QXmlStreamAttributes attrs(attributes());
 
2269
//                 TRY_READ_ATTR_WITHOUT_NS(val);
 
2270
//                 if ( val == "1" || val == "true" || val == "on " )
 
2271
//                 {                    
 
2272
//                     if ( m_currentSeries->markerType == Charting::Series::None )
 
2273
//                         switch ( d->m_numReadSeries )
 
2274
//                         {
 
2275
//                             case 0:
 
2276
//                                 m_currentSeries->markerType = Charting::Series::Square;
 
2277
//                                 break;
 
2278
//                             case 1:
 
2279
//                                 m_currentSeries->markerType = Charting::Series::Diamond;
 
2280
//                                 break;
 
2281
//                             default:
 
2282
//                                 break;
 
2283
//                         }
 
2284
//                     ++d->m_numReadSeries;
 
2285
//                 }
 
2286
//             }
 
2287
                
 
2288
        }
 
2289
    }
 
2290
 
 
2291
    // set data ranges and write data to internal table
 
2292
    m_currentSeries->m_countYValues = tempLineSeriesData->m_val.m_numRef.m_numCache.m_ptCount;
 
2293
 
 
2294
    m_currentSeries->m_labelCell = tempLineSeriesData->m_tx.writeRefToInternalTable(this);
 
2295
 
 
2296
    m_currentSeries->m_valuesCellRangeAddress = tempLineSeriesData->m_val.writeRefToInternalTable(this);
 
2297
 
 
2298
    m_context->m_chart->m_verticalCellRangeAddress = tempLineSeriesData->m_cat.writeRefToInternalTable(this);
 
2299
 
 
2300
    READ_EPILOGUE
 
2301
}
 
2302
 
 
2303
#undef CURRENT_EL
 
2304
#define CURRENT_EL marker
 
2305
KoFilter::ConversionStatus XlsxXmlChartReader::read_serMarker()
 
2306
{
 
2307
    using namespace Charting;
 
2308
    READ_PROLOGUE2( serMarker )
 
2309
    while (!atEnd()) {
 
2310
        readNext();
 
2311
        BREAK_IF_END_OF(CURRENT_EL);
 
2312
        if (isStartElement()) {
 
2313
            if ( qualifiedName() == "c:symbol" )
 
2314
            {
 
2315
                const QXmlStreamAttributes attrs(attributes());
 
2316
                TRY_READ_ATTR_WITHOUT_NS(val);
 
2317
                if ( val.toLower() == "star" )
 
2318
                    m_currentSeries->markerType = Series::Star;
 
2319
                else if ( val.toLower() == "dash" )
 
2320
                    m_currentSeries->markerType = Series::Dash;
 
2321
                else if ( val.toLower() == "dot" )
 
2322
                    m_currentSeries->markerType = Series::Dot;
 
2323
                else if ( val.toLower() == "plus" )
 
2324
                    m_currentSeries->markerType = Series::Plus;
 
2325
                else if ( val.toLower() == "circle" )
 
2326
                    m_currentSeries->markerType = Series::Circle;
 
2327
                else if ( val.toLower() == "x" )
 
2328
                    m_currentSeries->markerType = Series::SymbolX;
 
2329
                else if ( val.toLower() == "triangle" )
 
2330
                    m_currentSeries->markerType = Series::Triangle;
 
2331
                else if ( val.toLower() == "squre" )
 
2332
                    m_currentSeries->markerType = Series::Square;
 
2333
                else if ( val.toLower() == "diamond" )
 
2334
                    m_currentSeries->markerType = Series::Diamond;
 
2335
            }
 
2336
        }
 
2337
    }
 
2338
    READ_EPILOGUE
 
2339
}
 
2340
 
 
2341
#undef CURRENT_EL
 
2342
#define CURRENT_EL ser
 
2343
//! ser (Surface Chart Series)
 
2344
/*! ECMA-376, 21.2.2.169, p.3840.
 
2345
 
 
2346
 Parent elements:
 
2347
  - surface3DChart (§21.2.2.203)
 
2348
  - surfaceChart (§21.2.2.204)
 
2349
 
 
2350
 Child elements:
 
2351
  - [Done]cat (Category Axis Data) §21.2.2.24
 
2352
  - extLst (Chart Extensibility) §21.2.2.64
 
2353
  - [Done]idx (Index) §21.2.2.84
 
2354
  - marker (Marker) §21.2.2.106
 
2355
  - [Done]order (Order) §21.2.2.128
 
2356
  - spPr (Shape Properties) §21.2.2.197
 
2357
  - [Done]tx (Series Text) §21.2.2.215
 
2358
  - [Done]val (Values) §21.2.2.224
 
2359
*/
 
2360
 
 
2361
KoFilter::ConversionStatus XlsxXmlChartReader::read_surfaceChart_Ser()
 
2362
{
 
2363
    READ_PROLOGUE2(surfaceChart_Ser)
 
2364
 
 
2365
    m_currentSeries  = new Charting::Series();
 
2366
    m_context->m_chart->m_series << m_currentSeries;
 
2367
 
 
2368
    SurfaceSeries * tempSurfaceSeriesData = new SurfaceSeries();
 
2369
    d->m_seriesData << tempSurfaceSeriesData;
 
2370
 
 
2371
    d->m_currentIdx = &tempSurfaceSeriesData->m_idx;
 
2372
    d->m_currentOrder = &tempSurfaceSeriesData->m_order;
 
2373
    d->m_currentTx = &tempSurfaceSeriesData->m_tx;
 
2374
    d->m_currentCat = &tempSurfaceSeriesData->m_cat;
 
2375
    d->m_currentVal = &tempSurfaceSeriesData->m_val;
 
2376
 
 
2377
    while (!atEnd()) {
 
2378
        readNext();
 
2379
        BREAK_IF_END_OF(CURRENT_EL);
 
2380
        if (isStartElement()) {
 
2381
            TRY_READ_IF(order)
 
2382
            ELSE_TRY_READ_IF(idx)
 
2383
            if (QUALIFIED_NAME_IS(tx)) {
 
2384
                TRY_READ(seriesText_Tx)
 
2385
            }
 
2386
            ELSE_TRY_READ_IF(cat)
 
2387
            ELSE_TRY_READ_IF(val)
 
2388
        }
 
2389
    }
 
2390
 
 
2391
    // set data ranges and write data to internal table
 
2392
    m_currentSeries->m_countYValues = tempSurfaceSeriesData->m_val.m_numRef.m_numCache.m_ptCount;
 
2393
 
 
2394
    m_currentSeries->m_labelCell = tempSurfaceSeriesData->m_tx.writeRefToInternalTable(this);
 
2395
 
 
2396
    m_currentSeries->m_valuesCellRangeAddress = tempSurfaceSeriesData->m_val.writeRefToInternalTable(this);
 
2397
 
 
2398
    m_context->m_chart->m_verticalCellRangeAddress = tempSurfaceSeriesData->m_cat.writeRefToInternalTable(this);
 
2399
 
 
2400
    READ_EPILOGUE
 
2401
}
 
2402
 
 
2403
#undef CURRENT_EL
 
2404
#define CURRENT_EL barDir
 
2405
//! barDir (Bar Direction)
 
2406
/*! ECMA-376, 21.2.2.17, p.3763.
 
2407
 
 
2408
 Parent elements:
 
2409
  - bar3DChart (§21.2.2.15)
 
2410
  - barChart (§21.2.2.16)
 
2411
 
 
2412
 Attributes:
 
2413
  - [Done] val (Bar Direction Value)
 
2414
*/
 
2415
KoFilter::ConversionStatus XlsxXmlChartReader::read_barDir()
 
2416
{
 
2417
    const QXmlStreamAttributes attrs(attributes());
 
2418
    TRY_READ_ATTR_WITHOUT_NS(val)
 
2419
    m_context->m_chart->m_transpose = (val == "bar"); // "bar" or "col"
 
2420
    while (!atEnd()) {
 
2421
        BREAK_IF_END_OF(CURRENT_EL);
 
2422
        readNext();
 
2423
    }
 
2424
    return KoFilter::OK;
 
2425
}
 
2426
 
 
2427
#undef CURRENT_EL
 
2428
#define CURRENT_EL grouping
 
2429
//! grouping (Bar Grouping)
 
2430
/*! ECMA-376, 21.2.2.77, p.3794.
 
2431
 
 
2432
 Parent elements:
 
2433
  - bar3DChart (§21.2.2.15)
 
2434
  - barChart (§21.2.2.16)
 
2435
 
 
2436
 Attributes:
 
2437
  - [Done] val (Bar Grouping Value)
 
2438
*/
 
2439
KoFilter::ConversionStatus XlsxXmlChartReader::read_grouping()
 
2440
{
 
2441
    const QXmlStreamAttributes attrs(attributes());
 
2442
    TRY_READ_ATTR_WITHOUT_NS(val)
 
2443
    if(val == "stacked") {
 
2444
        m_context->m_chart->m_stacked = true;
 
2445
    } else if(val == "percentStacked") {
 
2446
        m_context->m_chart->m_stacked = true;
 
2447
        m_context->m_chart->m_f100 = true;
 
2448
    } else if(val == "clustered") {
 
2449
        //TODO
 
2450
    } // else if(val == "standard") is not needed cause that's the default anyway
 
2451
    while (!atEnd()) {
 
2452
        BREAK_IF_END_OF(CURRENT_EL);
 
2453
        readNext();
 
2454
    }
 
2455
    return KoFilter::OK;
 
2456
}
 
2457
 
 
2458
#undef CURRENT_EL
 
2459
#define CURRENT_EL firstSliceAng
 
2460
//! firstSliceAng (First Slice Angle)
 
2461
/*! ECMA-376, 21.2.2.68, p.3790.
 
2462
 
 
2463
 Parent elements:
 
2464
  - doughnutChart (§21.2.2.50)
 
2465
  - pieChart (§21.2.2.141)
 
2466
 
 
2467
 Child elements:
 
2468
  - val (First Slice Angle Value)
 
2469
*/
270
2470
KoFilter::ConversionStatus XlsxXmlChartReader::read_firstSliceAng()
271
2471
{
272
2472
    if(Charting::PieImpl* pie = dynamic_cast<Charting::PieImpl*>(m_context->m_chart->m_impl)) {
273
2473
        const QXmlStreamAttributes attrs(attributes());
274
 
        TRY_READ_ATTR(val)
 
2474
        QString val(attrs.value("val").toString());
275
2475
        pie->m_anStart = val.toInt(); // default value is zero
276
2476
    }
277
 
    return KoFilter::OK;
 
2477
    while (!atEnd()) {
 
2478
        BREAK_IF_END_OF(CURRENT_EL);
 
2479
        readNext();
 
2480
    }
 
2481
    return KoFilter::OK;
 
2482
}
 
2483
 
 
2484
#undef CURRENT_EL
 
2485
#define CURRENT_EL holeSize
 
2486
//! holeSize (Hole Size)
 
2487
/*! ECMA-376, 21.2.2.82, p.3797.
 
2488
 
 
2489
 Parent elements:
 
2490
  - doughnutChart (§21.2.2.50)
 
2491
 
 
2492
 Child elements:
 
2493
  - val (Hole Size Value)
 
2494
*/
 
2495
KoFilter::ConversionStatus XlsxXmlChartReader::read_holeSize()
 
2496
{
 
2497
    if(Charting::RingImpl* ring = dynamic_cast<Charting::RingImpl*>(m_context->m_chart->m_impl)) {
 
2498
        const QXmlStreamAttributes attrs(attributes());
 
2499
        QString val(attrs.value("val").toString());
 
2500
        ring->m_pcDonut = val.toInt(); // default value is zero
 
2501
    }
 
2502
    while (!atEnd()) {
 
2503
        BREAK_IF_END_OF(CURRENT_EL);
 
2504
        readNext();
 
2505
    }
 
2506
    return KoFilter::OK;
 
2507
}
 
2508
 
 
2509
#undef CURRENT_EL
 
2510
#define CURRENT_EL bubbleSize
 
2511
//! bubbleSize (Bubble Size)
 
2512
/*! ECMA-376, 21.2.2.22, p.3876.
 
2513
 
 
2514
 Parent elements:
 
2515
  - ser §21.2.2.174
 
2516
 
 
2517
 Child elements:
 
2518
  - numLit (Number Literal) §21.2.2.122
 
2519
  - [done]numRef (Number Reference) §21.2.2.123
 
2520
*/
 
2521
KoFilter::ConversionStatus XlsxXmlChartReader::read_bubbleSize()
 
2522
{
 
2523
    READ_PROLOGUE
 
2524
    d->m_currentNumRef = &d->m_currentBubbleSize->m_numRef;
 
2525
    d->m_currentNumLit = &d->m_currentBubbleSize->m_numLit;
 
2526
    while (!atEnd()) {
 
2527
        readNext();
 
2528
        BREAK_IF_END_OF(CURRENT_EL);
 
2529
        if (isStartElement()) {
 
2530
            TRY_READ_IF(numRef)
 
2531
            ELSE_TRY_READ_IF(numLit)
 
2532
 
 
2533
        }
 
2534
    }
 
2535
    READ_EPILOGUE
 
2536
}
 
2537
 
 
2538
#undef CURRENT_EL
 
2539
#define CURRENT_EL bubbleScale
 
2540
//! bubbleScale (Bubble Scale)
 
2541
/*! ECMA-376, 21.2.2.21, p.3765.
 
2542
 
 
2543
 Parent elements:
 
2544
  - bubbleChart (§21.2.2.20)
 
2545
 
 
2546
 Attributes:
 
2547
  - [Done] val (Bubble Scale Value)
 
2548
*/
 
2549
KoFilter::ConversionStatus XlsxXmlChartReader::read_bubbleScale()
 
2550
{
 
2551
    READ_PROLOGUE
 
2552
 
 
2553
    const QXmlStreamAttributes attrs(attributes());
 
2554
    QString val(attrs.value("val").toString());
 
2555
 
 
2556
    if(Charting::BubbleImpl* bubble = dynamic_cast<Charting::BubbleImpl*>(m_context->m_chart->m_impl)) {
 
2557
        bool ok;
 
2558
        const int i = val.toInt(&ok);
 
2559
        if(ok)
 
2560
            bubble->m_sizeRatio = i;
 
2561
    }
 
2562
    readNext();
 
2563
    READ_EPILOGUE
 
2564
}
 
2565
 
 
2566
#undef CURRENT_EL
 
2567
#define CURRENT_EL bubble3D
 
2568
//! bubble3D (3D Bubble)
 
2569
/*! ECMA-376, 21.2.2.21, p.3765.
 
2570
 
 
2571
 Parent elements:
 
2572
  - bubbleChart (§21.2.2.20)
 
2573
  - dPt (§21.2.2.52)
 
2574
  - ser (§21.2.2.174)
 
2575
 
 
2576
 Attributes:
 
2577
  - [Done] val (Boolean Value)
 
2578
*/
 
2579
KoFilter::ConversionStatus XlsxXmlChartReader::read_bubble3D()
 
2580
{
 
2581
    READ_PROLOGUE
 
2582
 
 
2583
    const QXmlStreamAttributes attrs(attributes());
 
2584
    QString val(attrs.value("val").toString());
 
2585
 
 
2586
    m_context->m_chart->m_is3d  = val.toInt();
 
2587
    readNext();
 
2588
    READ_EPILOGUE
 
2589
}
 
2590
 
 
2591
#undef CURRENT_EL
 
2592
#define CURRENT_EL numLit
 
2593
//! numLit (Number Literal)
 
2594
/*! ECMA-376, 21.2.2.122, p.3815.
 
2595
 
 
2596
 Parent elements:
 
2597
  - bubbleSize (§21.2.2.22)
 
2598
  - cat (§21.2.2.24)
 
2599
  - minus (§21.2.2.113)
 
2600
  - plus (§21.2.2.147)
 
2601
  - val (§21.2.2.224)
 
2602
  - xVal(§21.2.2.234)
 
2603
  - yVal (§21.2.2.237)
 
2604
 
 
2605
 Child elements:
 
2606
  - extLst (Chart Extensibility) §21.2.2.64
 
2607
  - formatCode (Format Code) §21.2.2.71
 
2608
  - [Done]pt (Numeric Point) §21.2.2.150
 
2609
  - [Done]ptCount (Point Count) §21.2.2.152
 
2610
*/
 
2611
KoFilter::ConversionStatus XlsxXmlChartReader::read_numLit()
 
2612
{
 
2613
    READ_PROLOGUE
 
2614
    d->m_currentPtCount = &d->m_currentNumLit->m_ptCount;
 
2615
    d->m_currentPtCache = &d->m_currentNumLit->m_cache;
 
2616
    while ( !atEnd() ) {
 
2617
        readNext();
 
2618
        BREAK_IF_END_OF( CURRENT_EL );
 
2619
        if ( isStartElement() ) {
 
2620
            TRY_READ_IF(ptCount)
 
2621
            ELSE_TRY_READ_IF(pt)
 
2622
        }
 
2623
    }
 
2624
    READ_EPILOGUE
 
2625
}
 
2626
 
 
2627
#undef CURRENT_EL
 
2628
#define CURRENT_EL pt
 
2629
//! pt (String Point)
 
2630
/*! ECMA-376, 21.2.2.151, p.3831.
 
2631
 
 
2632
 Parent elements:
 
2633
  - lvl (§21.2.2.99)
 
2634
  - strCache (§21.2.2.199)
 
2635
  - strLit (§21.2.2.200)
 
2636
 
 
2637
 Child elements:
 
2638
  - [Done]v (Text Value)
 
2639
 
 
2640
 Attributes:
 
2641
  - idx (Index)
 
2642
*/
 
2643
KoFilter::ConversionStatus XlsxXmlChartReader::read_pt()
 
2644
{
 
2645
    READ_PROLOGUE
 
2646
    while ( !atEnd() ) {
 
2647
        readNext();
 
2648
        BREAK_IF_END_OF( CURRENT_EL );
 
2649
        if ( isStartElement() ) {
 
2650
          if ( qualifiedName() == QLatin1String( QUALIFIED_NAME( v ) ) ) {
 
2651
              d->m_currentPtCache->append(readElementText());
 
2652
          }
 
2653
        }
 
2654
    }
 
2655
    READ_EPILOGUE
 
2656
}
 
2657
 
 
2658
#undef CURRENT_EL
 
2659
#define CURRENT_EL order
 
2660
//! order (Order)
 
2661
/*! ECMA-376, 21.2.2.128, p.3817.
 
2662
 
 
2663
 Parent elements:
 
2664
  - ser §21.2.2.168
 
2665
  - ser §21.2.2.170
 
2666
  - ser §21.2.2.174
 
2667
  - ser §21.2.2.171
 
2668
  - ser §21.2.2.172
 
2669
  - ser §21.2.2.169
 
2670
  - ser §21.2.2.167
 
2671
  - ser §21.2.2.173
 
2672
 
 
2673
 Attributes:
 
2674
  - [Done] val (Integer Value)
 
2675
*/
 
2676
KoFilter::ConversionStatus XlsxXmlChartReader::read_order()
 
2677
{
 
2678
    READ_PROLOGUE
 
2679
 
 
2680
    const QXmlStreamAttributes attrs(attributes());
 
2681
    QString val(attrs.value("val").toString());
 
2682
    *d->m_currentOrder = val.toInt();
 
2683
 
 
2684
    readNext();
 
2685
    READ_EPILOGUE
 
2686
}
 
2687
 
 
2688
#undef CURRENT_EL
 
2689
#define CURRENT_EL idx
 
2690
//! idx (Index)
 
2691
/*! ECMA-376, 21.2.2.84, p.3798.
 
2692
 
 
2693
 Parent elements:
 
2694
  - bandFmt (§21.2.2.13)
 
2695
  - dLbl (§21.2.2.47)
 
2696
  - dPt (§21.2.2.52)
 
2697
  - legendEntry (§21.2.2.94)
 
2698
  - pivotFmt (§21.2.2.142)
 
2699
  - ser §21.2.2.168
 
2700
  - ser §21.2.2.170
 
2701
  - ser §21.2.2.174
 
2702
  - ser §21.2.2.171
 
2703
  - ser §21.2.2.172
 
2704
  - ser §21.2.2.169
 
2705
  - ser §21.2.2.167
 
2706
  - ser §21.2.2.173
 
2707
 
 
2708
 Attributes:
 
2709
  - [Done] val (Integer Value)
 
2710
*/
 
2711
KoFilter::ConversionStatus XlsxXmlChartReader::read_idx()
 
2712
{
 
2713
    READ_PROLOGUE
 
2714
 
 
2715
    const QXmlStreamAttributes attrs(attributes());
 
2716
    QString val(attrs.value("val").toString());
 
2717
    *d->m_currentIdx = val.toInt();
 
2718
 
 
2719
    readNext();
 
2720
    READ_EPILOGUE
 
2721
}
 
2722
 
 
2723
#undef CURRENT_EL
 
2724
#define CURRENT_EL explosion
 
2725
//! explosion (Explosion)
 
2726
/*! ECMA-376, 21.2.2.61, p.3787.
 
2727
 
 
2728
 Parent elements:
 
2729
  - dPt (§21.2.2.52)
 
2730
  - ser (§21.2.2.172)
 
2731
 
 
2732
 Attributes:
 
2733
  - [Done] val (Integer Value)
 
2734
*/
 
2735
KoFilter::ConversionStatus XlsxXmlChartReader::read_explosion()
 
2736
{
 
2737
    READ_PROLOGUE
 
2738
 
 
2739
    const QXmlStreamAttributes attrs(attributes());
 
2740
    QString val(attrs.value("val").toString());
 
2741
    *d->m_currentExplosion = val.toInt();
 
2742
 
 
2743
    readNext();
 
2744
    READ_EPILOGUE
 
2745
}
 
2746
 
 
2747
#undef CURRENT_EL
 
2748
#define CURRENT_EL strRef
 
2749
//! strRef (String Reference)
 
2750
/*! ECMA-376, 21.2.2.201, p.3857.
 
2751
 
 
2752
 Parent elements:
 
2753
  - cat (§21.2.2.24)
 
2754
  - tx (§21.2.2.215)
 
2755
  - tx (§21.2.2.214)
 
2756
  - xVal (§21.2.2.234)
 
2757
 
 
2758
 Attributes:
 
2759
  - extLst (Chart Extensibility) §21.2.2.64
 
2760
  - [Done]f (Formula) §21.2.2.65
 
2761
  - [Done]strCache (String Cache) §21.2.2.199
 
2762
*/
 
2763
KoFilter::ConversionStatus XlsxXmlChartReader::read_strRef()
 
2764
{
 
2765
    READ_PROLOGUE
 
2766
 
 
2767
    d->m_currentF = &d->m_currentStrRef->m_f;
 
2768
    d->m_currentStrCache = &d->m_currentStrRef->m_strCache;
 
2769
 
 
2770
    while (!atEnd()) {
 
2771
        readNext();
 
2772
        BREAK_IF_END_OF(CURRENT_EL);
 
2773
        if (isStartElement()) {
 
2774
            TRY_READ_IF(f)
 
2775
            ELSE_TRY_READ_IF(strCache)
 
2776
        }
 
2777
    }
 
2778
    READ_EPILOGUE
 
2779
}
 
2780
 
 
2781
#undef CURRENT_EL
 
2782
#define CURRENT_EL numRef
 
2783
//! numRef (String Reference)
 
2784
/*! ECMA-376, 21.2.2.123, p.3815.
 
2785
 
 
2786
 Parent elements:
 
2787
  - bubbleSize (§21.2.2.22)
 
2788
  - cat (§21.2.2.24)
 
2789
  - minus (§21.2.2.113)
 
2790
  - plus (§21.2.2.147)
 
2791
  - val (§21.2.2.224)
 
2792
  - xVal (§21.2.2.234)
 
2793
  - yVal (§21.2.2.237)
 
2794
 
 
2795
 Child elements:
 
2796
  - extLst (Chart Extensibility) §21.2.2.64
 
2797
  - [Done]f (Formula) §21.2.2.65
 
2798
  - [Done]numCache (Number Cache) §21.2.2.120
 
2799
*/
 
2800
KoFilter::ConversionStatus XlsxXmlChartReader::read_numRef()
 
2801
{
 
2802
    READ_PROLOGUE
 
2803
 
 
2804
    d->m_currentF = &d->m_currentNumRef->m_f;
 
2805
    d->m_currentNumCache = &d->m_currentNumRef->m_numCache;
 
2806
 
 
2807
    while (!atEnd()) {
 
2808
        readNext();
 
2809
        BREAK_IF_END_OF(CURRENT_EL);
 
2810
        if (isStartElement()) {
 
2811
            TRY_READ_IF(f)
 
2812
            ELSE_TRY_READ_IF(numCache)
 
2813
        }
 
2814
    }
 
2815
    READ_EPILOGUE
 
2816
}
 
2817
 
 
2818
#undef CURRENT_EL
 
2819
#define CURRENT_EL f
 
2820
//! f (Formula)
 
2821
/*! ECMA-376, 21.2.2.65, p.3789.
 
2822
 
 
2823
 Parent elements:
 
2824
  - multiLvlStrRef (§21.2.2.115)
 
2825
  - numRef (§21.2.2.123)
 
2826
  - strRef (§21.2.2.201)
 
2827
*/
 
2828
KoFilter::ConversionStatus XlsxXmlChartReader::read_f()
 
2829
{
 
2830
    READ_PROLOGUE
 
2831
 
 
2832
    const QXmlStreamAttributes attrs(attributes());
 
2833
    *d->m_currentF = readElementText();
 
2834
    while (!atEnd()) {
 
2835
        BREAK_IF_END_OF(CURRENT_EL);
 
2836
        readNext();
 
2837
    }
 
2838
 
 
2839
    if (d->m_currentF->size() != 0) {
 
2840
        QPair<QString,QRect> result = splitCellRange( *d->m_currentF );
 
2841
        m_context->m_chart->addRange( result.second );
 
2842
    }
 
2843
 
 
2844
    READ_EPILOGUE
 
2845
}
 
2846
 
 
2847
#undef CURRENT_EL
 
2848
#define CURRENT_EL ptCount
 
2849
//! ptCount (Point Count)
 
2850
/*! ECMA-376, 21.2.2.152, p.3832.
 
2851
 
 
2852
 Parent elements:
 
2853
  - multiLvlStrCache (§21.2.2.114)
 
2854
  - numCache (§21.2.2.120)
 
2855
  - numLit (§21.2.2.122)
 
2856
  - strCache (§21.2.2.199)
 
2857
  - strLit (§21.2.2.200)
 
2858
 
 
2859
 Attributes:
 
2860
  - [Done] val (Integer Value)
 
2861
*/
 
2862
KoFilter::ConversionStatus XlsxXmlChartReader::read_ptCount()
 
2863
{
 
2864
    READ_PROLOGUE
 
2865
 
 
2866
    const QXmlStreamAttributes attrs(attributes());
 
2867
    QString val(attrs.value("val").toString());
 
2868
    *d->m_currentPtCount = val.toInt();
 
2869
 
 
2870
    readNext();
 
2871
    READ_EPILOGUE
 
2872
}
 
2873
 
 
2874
#undef CURRENT_EL
 
2875
#define CURRENT_EL strCache
 
2876
//! strCache (String Cache)
 
2877
/*! ECMA-376, 21.2.2.199, p.3856.
 
2878
 
 
2879
 Parent elements:
 
2880
 - strRef (§21.2.2.201)
 
2881
 
 
2882
 Child elements:
 
2883
  - extLst (Chart Extensibility) §21.2.2.64
 
2884
  - [Done]pt (String Point) §21.2.2.151
 
2885
  - [Done]ptCount (Point Count) §21.2.2.152
 
2886
 
 
2887
*/
 
2888
KoFilter::ConversionStatus XlsxXmlChartReader::read_strCache()
 
2889
{
 
2890
    READ_PROLOGUE
 
2891
 
 
2892
    d->m_currentPtCount = &d->m_currentStrCache->m_ptCount;
 
2893
    d->m_currentPtCache = &d->m_currentStrCache->m_cache;
 
2894
 
 
2895
    while (!atEnd()) {
 
2896
        readNext();
 
2897
        BREAK_IF_END_OF(CURRENT_EL);
 
2898
        if (isStartElement()) {
 
2899
            TRY_READ_IF(ptCount)
 
2900
            ELSE_TRY_READ_IF(pt)
 
2901
        }
 
2902
    }
 
2903
    READ_EPILOGUE
 
2904
}
 
2905
 
 
2906
int charToInt( const QString& string )
 
2907
{
 
2908
    if (string.isEmpty()) {
 
2909
        return -1;
 
2910
    }
 
2911
 
 
2912
    int ret = 0;
 
2913
    int multiplier = 1;
 
2914
    for(int i=string.size()-1; i>-1; i--,multiplier = multiplier*26) {
 
2915
        char val = string[i].toAscii();
 
2916
        if ( val >= 65 && val <= 90 ) {
 
2917
            ret = ret +  (val - 64)*multiplier;
 
2918
        } else {
 
2919
            ret = -1;
 
2920
            break;
 
2921
        }
 
2922
    }
 
2923
    return ret;
 
2924
}
 
2925
 
 
2926
QString XlsxXmlChartReader::AlocateAndWriteIntoInternalTable(QVector< QString > &buffer, QString format)
 
2927
{
 
2928
    if (buffer.size() == 0)
 
2929
        return QString();
 
2930
 
 
2931
    //create range where to place the data
 
2932
    QString range("local");
 
2933
    Charting::InternalTable *internalTable = &m_context->m_chart->m_internalTable;
 
2934
 
 
2935
    range += "!$" + columnName(internalTable->maxColumn()+1) +"$" + "1" + ":$" + columnName(internalTable->maxColumn()+1) +
 
2936
             "$" + QString::number(buffer.size());
 
2937
 
 
2938
    WriteIntoInternalTable(range, buffer, format);
 
2939
    return range;
 
2940
}
 
2941
 
 
2942
void XlsxXmlChartReader::WriteIntoInternalTable(QString &range, QVector< QString > &buffer, QString format)
 
2943
{
 
2944
    if(range.isEmpty()) {
 
2945
        return;
 
2946
    }
 
2947
    const QString sheet = range.section( '!', 0, 0 );
 
2948
    const QString cellRange = range.section( '!', 1, -1 );
 
2949
    const QStringList& res = cellRange.split( QRegExp( "[$:]" ), QString::SkipEmptyParts );
 
2950
 
 
2951
    if (res.isEmpty()) {
 
2952
        return;
 
2953
    }
 
2954
 
 
2955
    int startColumn = charToInt( res[ 0 ] );
 
2956
    int startRow = res[ 1 ].toInt();
 
2957
    int endColumn = 0;
 
2958
    int endRow = 0;
 
2959
    if (res.size() >= 4) {
 
2960
        endColumn = charToInt( res[ 2 ] );
 
2961
        endRow = res[ 3 ].toInt();
 
2962
    } else {
 
2963
        endColumn = startColumn ;
 
2964
        endRow = startRow;
 
2965
    }
 
2966
 
 
2967
//    kDebug()<<"range " << range;
 
2968
//    kDebug()<<"sheet " << sheet;
 
2969
//    kDebug()<<"cellRange " << cellRange;
 
2970
//    kDebug()<<"startColumn " << startColumn;
 
2971
//    kDebug()<<"startRow " << startRow;
 
2972
//    kDebug()<<"endColumn " << endColumn;
 
2973
//    kDebug()<<"endRow " << endRow;
 
2974
//
 
2975
//    kDebug()<<"buffer.size() " << buffer.size();
 
2976
 
 
2977
    Charting::InternalTable *internalTable = &m_context->m_chart->m_internalTable;
 
2978
    if (startColumn < endColumn) {
 
2979
        if ((endColumn - startColumn +1) == buffer.size()) {
 
2980
 
 
2981
            int bufferIndex = 0;
 
2982
            for(int i = startColumn; i <=endColumn; i++,bufferIndex++) {
 
2983
                Charting::Cell *cell = internalTable->cell(i,startRow,true);
 
2984
                cell->m_valueType = format;
 
2985
                cell->m_value = buffer[bufferIndex];
 
2986
//                kDebug()<<"m_value " << format;
 
2987
//                kDebug()<<"buffer[bufferIndex] " << buffer[bufferIndex];
 
2988
//                kDebug()<<"cell row" << startRow;
 
2989
//                kDebug()<<"cell column " << i;
 
2990
            }
 
2991
        }
 
2992
    } else if (startRow < endRow){
 
2993
        if ((endRow - startRow +1) == buffer.size()) {
 
2994
 
 
2995
            int bufferIndex = 0;
 
2996
            for(int i = startRow; i <=endRow; i++,bufferIndex++) {
 
2997
                Charting::Cell *cell = internalTable->cell(startColumn,i,true);
 
2998
                cell->m_valueType = format;
 
2999
                cell->m_value = buffer[bufferIndex];
 
3000
//                kDebug()<<"m_value " << format;
 
3001
//                kDebug()<<"buffer[bufferIndex] " << buffer[bufferIndex];
 
3002
//                kDebug()<<"cell row" << i;
 
3003
//                kDebug()<<"cell column " << startColumn;
 
3004
            }
 
3005
        }
 
3006
    } else {
 
3007
        if (buffer.size() != 0) {
 
3008
            Charting::Cell *cell = internalTable->cell(startColumn,startRow,true);
 
3009
            cell->m_valueType = format;
 
3010
            cell->m_value = buffer[0];
 
3011
//            kDebug()<<"m_value " << format;
 
3012
//            kDebug()<<"buffer[bufferIndex] " << buffer[0];
 
3013
//            kDebug()<<"cell row" << startRow;
 
3014
//            kDebug()<<"cell column " << startColumn;
 
3015
        }
 
3016
    }
278
3017
}