Subversion Repositories Scribus

Rev

Rev 6570 | Rev 7481 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4430 cbradney 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
21 Franz 7
/***************************************************************************
8
                          svgexplugin.cpp  -  description
9
                             -------------------
10
    begin                : Sun Aug 3 08:00:00 CEST 2002
11
    copyright            : (C) 2002 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
766 cbradney 23
 
24
#include <qfile.h>
25
#include <qtextstream.h>
26
 
21 Franz 27
#include "svgexplugin.h"
512 fschmid 28
 
2688 craig 29
#include "scconfig.h"
5781 cbradney 30
#include "cmsettings.h"
4546 subik 31
#include "commonstrings.h"
21 Franz 32
#include "customfdialog.h"
5781 cbradney 33
#include "scribuscore.h"
3670 cbradney 34
#include "page.h"
68 Franz 35
#ifdef HAVE_LIBZ
36
#include <zlib.h>
37
#endif
2856 cbradney 38
#include "prefsmanager.h"
3670 cbradney 39
#include "prefsfile.h"
40
#include "prefscontext.h"
3953 cbradney 41
#include "scmessagebox.h"
2533 craig 42
#include "util.h"
4182 subik 43
#include "customfdialog.h"
5346 mrdocs 44
#include "sctextstruct.h"
5087 subik 45
#include "guidemanager.h"
1552 subik 46
 
4182 subik 47
 
3207 craig 48
int svgexplugin_getPluginAPIVersion()
21 Franz 49
{
3207 craig 50
        return PLUGIN_API_VERSION;
21 Franz 51
}
52
 
3207 craig 53
ScPlugin* svgexplugin_getPlugin()
21 Franz 54
{
3207 craig 55
        SVGExportPlugin* plug = new SVGExportPlugin();
56
        Q_CHECK_PTR(plug);
57
        return plug;
21 Franz 58
}
59
 
3207 craig 60
void svgexplugin_freePlugin(ScPlugin* plugin)
512 fschmid 61
{
3207 craig 62
        SVGExportPlugin* plug = dynamic_cast<SVGExportPlugin*>(plugin);
63
        Q_ASSERT(plug);
64
        delete plug;
512 fschmid 65
}
66
 
3686 craig 67
SVGExportPlugin::SVGExportPlugin() : ScActionPlugin()
1208 cbradney 68
{
3207 craig 69
        // Set action info in languageChange, so we only have to do
70
        // it in one place.
71
        languageChange();
1208 cbradney 72
}
73
 
3207 craig 74
SVGExportPlugin::~SVGExportPlugin() {};
75
 
76
void SVGExportPlugin::languageChange()
1208 cbradney 77
{
3207 craig 78
        // Note that we leave the unused members unset. They'll be initialised
79
        // with their default ctors during construction.
80
        // Action name
81
        m_actionInfo.name = "ExportAsSVG";
82
        // Action text for menu, including accel
5357 cbradney 83
        m_actionInfo.text = tr("Save as &SVG...");
3207 craig 84
        // Menu
85
        m_actionInfo.menu = "FileExport";
86
        m_actionInfo.enabledOnStartup = true;
1208 cbradney 87
}
88
 
3207 craig 89
const QString SVGExportPlugin::fullTrName() const
1208 cbradney 90
{
3207 craig 91
        return QObject::tr("SVG Export");
1208 cbradney 92
}
93
 
3207 craig 94
const ScActionPlugin::AboutData* SVGExportPlugin::getAboutData() const
1208 cbradney 95
{
3241 craig 96
        AboutData* about = new AboutData;
3344 fschmid 97
        about->authors = "Franz Schmid <franz@scribus.info>";
3355 cbradney 98
        about->shortDescription = tr("Exports SVG Files");
3357 cbradney 99
        about->description = tr("Exports the current page into an SVG file.");
3344 fschmid 100
        about->license = "GPL";
3241 craig 101
        Q_CHECK_PTR(about);
102
        return about;
1208 cbradney 103
}
104
 
3241 craig 105
void SVGExportPlugin::deleteAboutData(const AboutData* about) const
1208 cbradney 106
{
3241 craig 107
        Q_ASSERT(about);
108
        delete about;
1208 cbradney 109
}
110
 
5781 cbradney 111
bool SVGExportPlugin::run(ScribusDoc* doc, QString filename)
21 Franz 112
{
3207 craig 113
        Q_ASSERT(filename.isEmpty());
4182 subik 114
        QString fileName;
5781 cbradney 115
        if (doc!=0)
2875 subik 116
        {
2856 cbradney 117
                PrefsContext* prefs = PrefsManager::instance()->prefsFile->getPluginContext("svgex");
415 Franz 118
                QString wdir = prefs->get("wdir", ".");
68 Franz 119
#ifdef HAVE_LIBZ
5846 jghali 120
                CustomFDialog *openDia = new CustomFDialog(doc->scMW(), wdir, QObject::tr("Save as"), QObject::tr("SVG-Images (*.svg *.svgz);;All Files (*)"), fdCompressFile);
68 Franz 121
#else
5846 jghali 122
                CustomFDialog *openDia = new CustomFDialog(doc->scMW(), wdir, QObject::tr("Save as"), QObject::tr("SVG-Images (*.svg);;All Files (*)"), fdNone);
68 Franz 123
#endif
5781 cbradney 124
                openDia->setSelection(getFileNameByPage(doc, doc->currentPage()->pageNr(), "svg"));
4182 subik 125
                openDia->setExtension("svg");
126
                openDia->setZipExtension("svgz");
127
                if (openDia->exec())
7386 fschmid 128
                {
129
#ifdef HAVE_LIBZ
130
                        if (openDia->SaveZip->isChecked())
131
                                openDia->handleCompress();
132
#endif
4182 subik 133
                        fileName = openDia->selectedFile();
7386 fschmid 134
                }
4182 subik 135
                delete openDia;
136
 
21 Franz 137
                if (!fileName.isEmpty())
2875 subik 138
                {
139
                        prefs->set("wdir", fileName.left(fileName.findRev("/")));
140
                        QFile f(fileName);
141
                        if (f.exists())
21 Franz 142
                        {
5781 cbradney 143
                                int exit=ScMessageBox::warning(doc->scMW(), CommonStrings::trWarning,
2875 subik 144
                                        QObject::tr("Do you really want to overwrite the File:\n%1 ?").arg(fileName),
6548 subik 145
                                        CommonStrings::trYes,
146
                                        CommonStrings::trNo,
2875 subik 147
                                        0, 0, 1);
148
                                if (exit != 0)
3207 craig 149
                                        return true;
21 Franz 150
                        }
5781 cbradney 151
                        SVGExPlug *dia = new SVGExPlug(doc, fileName);
2875 subik 152
                        delete dia;
153
                }
21 Franz 154
                else
3207 craig 155
                        return true;
2875 subik 156
        }
3207 craig 157
        return true;
21 Franz 158
}
159
 
5781 cbradney 160
SVGExPlug::SVGExPlug( ScribusDoc* doc, QString fName )
21 Franz 161
{
5471 fschmid 162
#ifdef USECAIRO
163
        Page *Seite;
5781 cbradney 164
        m_Doc=doc;
165
        m_View=m_Doc->view();
166
        m_ScMW=m_Doc->scMW();
167
        Seite = m_Doc->currentPage();
5471 fschmid 168
        int clipx = static_cast<int>(Seite->xOffset());
169
        int clipy = static_cast<int>(Seite->yOffset());
170
        int clipw = qRound(Seite->width());
171
        int cliph = qRound(Seite->height());
5781 cbradney 172
        double sca = m_View->scale();
173
        double cx = m_Doc->minCanvasCoordinate.x();
174
        double cy = m_Doc->minCanvasCoordinate.y();
175
        m_Doc->minCanvasCoordinate = FPoint(0, 0);
176
        bool frs = m_Doc->guidesSettings.framesShown;
177
        m_Doc->guidesSettings.framesShown = false;
178
        m_View->setScale(1.0);
179
        m_View->previewMode = true;
5471 fschmid 180
        ScPainter *painter = new ScPainter(fName, clipw, cliph, 1.0, 0);
5781 cbradney 181
        painter->clear(m_Doc->papColor);
5471 fschmid 182
        painter->translate(-clipx, -clipy);
183
        painter->setFillMode(ScPainter::Solid);
5781 cbradney 184
        m_View->DrawMasterItems(painter, Seite, QRect(clipx, clipy, clipw, cliph));
185
        m_View->DrawPageItems(painter, QRect(clipx, clipy, clipw, cliph));
5471 fschmid 186
        painter->end();
5781 cbradney 187
        m_Doc->guidesSettings.framesShown = frs;
188
        m_View->setScale(sca);
5471 fschmid 189
        delete painter;
5781 cbradney 190
        m_View->previewMode = false;
191
        m_Doc->minCanvasCoordinate = FPoint(cx, cy);
5471 fschmid 192
#else
21 Franz 193
        QDomDocument docu("svgdoc");
68 Franz 194
        QString vo = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
21 Franz 195
        QString st = "<svg></svg>";
196
        docu.setContent(st);
197
        QDomElement elem = docu.documentElement();
5781 cbradney 198
        elem.setAttribute("width", FToStr(m_Doc->pageWidth)+"pt");
199
        elem.setAttribute("height", FToStr(m_Doc->pageHeight)+"pt");
68 Franz 200
        elem.setAttribute("xmlns", "http://www.w3.org/2000/svg");
1552 subik 201
        elem.setAttribute("xmlns:xlink","http://www.w3.org/1999/xlink");
21 Franz 202
        Page *Seite;
203
        GradCount = 0;
22 Franz 204
        ClipCount = 0;
5781 cbradney 205
        Seite = m_Doc->MasterPages.at(m_Doc->MasterNames[m_Doc->currentPage()->MPageNam]);
3207 craig 206
        ProcessPage(Seite, &docu, &elem);
5781 cbradney 207
        Seite = m_Doc->currentPage();
3207 craig 208
        ProcessPage(Seite, &docu, &elem);
68 Franz 209
#ifdef HAVE_LIBZ
210
        if(fName.right(2) == "gz")
6014 jghali 211
        {
68 Franz 212
// zipped saving
213
                gzFile gzDoc = gzopen(fName.latin1(),"wb");
214
                if(gzDoc == NULL)
215
                        return;
216
                gzputs(gzDoc, vo);
217
                gzputs(gzDoc, docu.toString().utf8());
218
                gzclose(gzDoc);
6014 jghali 219
        }
68 Franz 220
        else
6014 jghali 221
        {
68 Franz 222
                QFile f(fName);
223
                if(!f.open(IO_WriteOnly))
224
                        return;
225
                QTextStream s(&f);
226
                QString wr = vo;
6014 jghali 227
                wr += docu.toString();
228
                QCString utf8wr = wr.utf8();
229
                s.writeRawBytes(utf8wr.data(), utf8wr.length());
68 Franz 230
                f.close();
6014 jghali 231
        }
68 Franz 232
#else
21 Franz 233
        QFile f(fName);
234
        if(!f.open(IO_WriteOnly))
235
                return;
236
        QTextStream s(&f);
68 Franz 237
        QString wr = vo;
6014 jghali 238
        wr += docu.toString();
239
        QCString utf8wr = wr.utf8();
240
        s.writeRawBytes(utf8wr.data(), utf8wr.length());
21 Franz 241
        f.close();
68 Franz 242
#endif
5471 fschmid 243
#endif
21 Franz 244
}
245
 
5697 fschmid 246
#ifndef USECAIRO
3207 craig 247
void SVGExPlug::ProcessPage(Page *Seite, QDomDocument *docu, QDomElement *elem)
21 Franz 248
{
55 Franz 249
        QString tmp, trans, fill, stroke, strokeW, strokeLC, strokeLJ, strokeDA, gradi, Clipi, chx;
5721 avox 250
        int d;
5346 mrdocs 251
        ScText *hl;
21 Franz 252
        int Lnr = 0;
253
        struct Layer ll;
1065 cbradney 254
        ll.isPrintable = false;
21 Franz 255
        ll.LNr = 0;
256
        QDomElement ob, gr, tp, tp2, defi, grad;
257
        QDomText tp1;
258
        PageItem *Item;
259
        gradi = "Grad";
22 Franz 260
        Clipi = "Clip";
456 fschmid 261
        QPtrList<PageItem> Items;
5781 cbradney 262
        Page* SavedAct = m_Doc->currentPage();
263
        m_Doc->setCurrentPage(Seite);
5685 cbradney 264
        if (Seite->pageName().isEmpty())
5781 cbradney 265
                Items = m_Doc->DocItems;
456 fschmid 266
        else
5781 cbradney 267
                Items = m_Doc->MasterItems;
268
        for (uint la = 0; la < m_Doc->Layers.count(); la++)
21 Franz 269
                {
5781 cbradney 270
                Level2Layer(m_Doc, &ll, Lnr);
1065 cbradney 271
                if (ll.isPrintable)
21 Franz 272
                        {
456 fschmid 273
                        for(uint j = 0; j < Items.count(); ++j)
274
                        {
275
                                Item = Items.at(j);
21 Franz 276
                                if (Item->LayerNr != ll.LNr)
277
                                        continue;
4726 fschmid 278
                                double x = Seite->xOffset();
279
                                double y = Seite->yOffset();
280
                                double w = Seite->width();
281
                                double h = Seite->height();
282
                                double x2 = Item->BoundingX;
283
                                double y2 = Item->BoundingY;
284
                                double w2 = Item->BoundingW;
285
                                double h2 = Item->BoundingH;
286
                                if (!( QMAX( x, x2 ) <= QMIN( x+w, x2+w2 ) && QMAX( y, y2 ) <= QMIN( y+h, y2+h2 )))
456 fschmid 287
                                        continue;
4546 subik 288
                                if ((Item->fillColor() != CommonStrings::None) || (Item->GrType != 0))
456 fschmid 289
                                {
3207 craig 290
                                        fill = "fill:"+SetFarbe(Item->fillColor(), Item->fillShade())+";";
21 Franz 291
                                        if (Item->GrType != 0)
456 fschmid 292
                                        {
21 Franz 293
                                                defi = docu->createElement("defs");
295 Franz 294
                                                if ((Item->GrType == 5) || (Item->GrType == 7))
21 Franz 295
                                                        grad = docu->createElement("radialGradient");
296
                                                else
297
                                                        grad = docu->createElement("linearGradient");
298
                                                grad.setAttribute("id", gradi+IToStr(GradCount));
22 Franz 299
                                                grad.setAttribute("gradientUnits", "userSpaceOnUse");
21 Franz 300
                                                switch (Item->GrType)
456 fschmid 301
                                                {
21 Franz 302
                                                        case 1:
303
                                                                grad.setAttribute("x1", "0");
3934 cbradney 304
                                                                grad.setAttribute("y1", FToStr(Item->height() / 2));
305
                                                                grad.setAttribute("x2", FToStr(Item->width()));
306
                                                                grad.setAttribute("y2", FToStr(Item->height() / 2));
21 Franz 307
                                                                break;
308
                                                        case 2:
3934 cbradney 309
                                                                grad.setAttribute("x1", FToStr(Item->width()/ 2));
21 Franz 310
                                                                grad.setAttribute("y1", "0");
3934 cbradney 311
                                                                grad.setAttribute("x2", FToStr(Item->width()/ 2));
312
                                                                grad.setAttribute("y2", FToStr(Item->height()));
21 Franz 313
                                                                break;
314
                                                        case 3:
315
                                                                grad.setAttribute("x1", "0");
316
                                                                grad.setAttribute("y1", "0");
3934 cbradney 317
                                                                grad.setAttribute("x2", FToStr(Item->width()));
318
                                                                grad.setAttribute("y2", FToStr(Item->height()));
21 Franz 319
                                                                break;
320
                                                        case 4:
295 Franz 321
                                                                grad.setAttribute("x1", "0");
3934 cbradney 322
                                                                grad.setAttribute("y1", FToStr(Item->height()));
323
                                                                grad.setAttribute("x2", FToStr(Item->width()));
295 Franz 324
                                                                grad.setAttribute("y2", "0");
21 Franz 325
                                                                break;
326
                                                        case 5:
3934 cbradney 327
                                                                grad.setAttribute("r", FToStr(QMAX(Item->width() / 2, Item->height() / 2)));
328
                                                                grad.setAttribute("cx", FToStr(Item->width() / 2));
329
                                                                grad.setAttribute("cy", FToStr(Item->height() / 2));
21 Franz 330
                                                                break;
292 Franz 331
                                                        case 6:
332
                                                                grad.setAttribute("x1", FToStr(Item->GrStartX));
333
                                                                grad.setAttribute("y1", FToStr(Item->GrStartY));
334
                                                                grad.setAttribute("x2", FToStr(Item->GrEndX));
335
                                                                grad.setAttribute("y2", FToStr(Item->GrEndY));
336
                                                                break;
295 Franz 337
                                                        case 7:
3934 cbradney 338
                                                                grad.setAttribute("r", FToStr(QMAX(Item->width() / 2, Item->height() / 2)));
295 Franz 339
                                                                grad.setAttribute("cx", FToStr(Item->GrStartX));
340
                                                                grad.setAttribute("cy", FToStr(Item->GrStartY));
341
                                                                break;
456 fschmid 342
                                                }
295 Franz 343
                                                QPtrVector<VColorStop> cstops = Item->fill_gradient.colorStops();
344
                                                for (uint cst = 0; cst < Item->fill_gradient.Stops(); ++cst)
345
                                                {
346
                                                        QDomElement itcl = docu->createElement("stop");
347
                                                        itcl.setAttribute("offset", FToStr(cstops.at(cst)->rampPoint*100)+"%");
348
                                                        itcl.setAttribute("stop-opacity", FToStr(cstops.at(cst)->opacity));
3207 craig 349
                                                        itcl.setAttribute("stop-color", SetFarbe(cstops.at(cst)->name, cstops.at(cst)->shade));
295 Franz 350
                                                        grad.appendChild(itcl);
351
                                                }
21 Franz 352
                                                defi.appendChild(grad);
353
                                                fill = "fill:url(#"+gradi+IToStr(GradCount)+");";
354
                                                GradCount++;
456 fschmid 355
                                        }
4477 fschmid 356
                                        if (Item->fillRule)
357
                                                fill += " fill-rule:evenodd;";
358
                                        else
359
                                                fill += " fill-rule:nonzero;";
1394 cbradney 360
                                        if (Item->fillTransparency() != 0)
1552 subik 361
                                                fill += " fill-opacity:"+FToStr(1.0 - Item->fillTransparency())+";";
456 fschmid 362
                                }
21 Franz 363
                                else
364
                                        fill = "fill:none;";
4546 subik 365
                                if (Item->lineColor() != CommonStrings::None)
456 fschmid 366
                                {
3207 craig 367
                                        stroke = "stroke:"+SetFarbe(Item->lineColor(), Item->lineShade())+";";
1394 cbradney 368
                                        if (Item->lineTransparency() != 0)
369
                                                stroke += " stroke-opacity:"+FToStr(1.0 - Item->lineTransparency())+";";
1552 subik 370
                                }
21 Franz 371
                                else
372
                                        stroke = "stroke:none;";
3903 cbradney 373
                                trans = "translate("+FToStr(Item->xPos()-Seite->xOffset())+", "+FToStr(Item->yPos()-Seite->yOffset())+")";
3934 cbradney 374
                                if (Item->rotation() != 0)
375
                                        trans += " rotate("+FToStr(Item->rotation())+")";
4580 cbradney 376
                                strokeW = "stroke-width:"+FToStr(Item->lineWidth())+"pt;";
21 Franz 377
                                strokeLC = "stroke-linecap:";
378
                                switch (Item->PLineEnd)
456 fschmid 379
                                {
21 Franz 380
                                        case Qt::FlatCap:
381
                                                strokeLC += "butt;";
382
                                                break;
383
                                        case Qt::SquareCap:
384
                                                strokeLC += "square;";
385
                                                break;
386
                                        case Qt::RoundCap:
387
                                                strokeLC += "round;";
388
                                                break;
389
                                        default:
390
                                                strokeLC += "butt;";
391
                                                break;
456 fschmid 392
                                }
21 Franz 393
                                strokeLJ = "stroke-linejoin:";
394
                                switch (Item->PLineJoin)
456 fschmid 395
                                {
21 Franz 396
                                        case Qt::MiterJoin:
397
                                                strokeLJ += "miter;";
398
                                                break;
399
                                        case Qt::BevelJoin:
400
                                                strokeLJ += "bevel;";
401
                                                break;
402
                                        case Qt::RoundJoin:
403
                                                strokeLJ += "round;";
404
                                                break;
405
                                        default:
406
                                                strokeLJ += "miter;";
407
                                                break;
456 fschmid 408
                                }
21 Franz 409
                                strokeDA = "stroke-dasharray:";
292 Franz 410
                                if (Item->DashValues.count() != 0)
411
                                {
412
                                        QValueList<double>::iterator it;
413
                                        for ( it = Item->DashValues.begin(); it != Item->DashValues.end(); ++it )
21 Franz 414
                                        {
292 Franz 415
                                                strokeDA += IToStr(static_cast<int>(*it))+" ";
21 Franz 416
                                        }
292 Franz 417
                                        strokeDA += "; stroke-dashoffset:"+IToStr(static_cast<int>(Item->DashOffset))+";";
418
                                }
419
                                else
420
                                {
4580 cbradney 421
                                        QString Dt = FToStr(QMAX(2*Item->lineWidth(), 1));
422
                                        QString Da = FToStr(QMAX(6*Item->lineWidth(), 1));
292 Franz 423
                                        switch (Item->PLineArt)
456 fschmid 424
                                        {
292 Franz 425
                                                case Qt::SolidLine:
426
                                                        strokeDA += "none;";
427
                                                        break;
428
                                                case Qt::DashLine:
429
                                                        strokeDA += Da+","+Dt+";";
430
                                                        break;
431
                                                case Qt::DotLine:
432
                                                        strokeDA += Dt+";";
433
                                                        break;
434
                                                case Qt::DashDotLine:
435
                                                        strokeDA += Da+","+Dt+","+Dt+","+Dt+";";
436
                                                        break;
437
                                                case Qt::DashDotDotLine:
438
                                                        strokeDA += Da+","+Dt+","+Dt+","+Dt+","+Dt+","+Dt+";";
439
                                                        break;
440
                                                default:
441
                                                        strokeDA += "none;";
442
                                                        break;
443
                                                }
444
                                }
21 Franz 445
                                gr = docu->createElement("g");
446
                                gr.setAttribute("transform", trans);
3625 avox 447
                                if (!Item->asTextFrame())
456 fschmid 448
                                {
2877 cbradney 449
                                        if (Item->NamedLStyle.isEmpty())
21 Franz 450
                                        {
3625 avox 451
                                                if ((Item->asLine()) || (Item->asPolyLine()) || (Item->asPathText()))
27 Franz 452
                                                        gr.setAttribute("style", "fill:none; "+stroke+" "+strokeW+" "+strokeLC+" "+strokeLJ+" "+strokeDA);
453
                                                else
454
                                                        gr.setAttribute("style", fill+" "+stroke+" "+strokeW+" "+strokeLC+" "+strokeLJ+" "+strokeDA);
21 Franz 455
                                        }
456 fschmid 456
                                }
1460 cbradney 457
                                switch (Item->itemType())
456 fschmid 458
                                {
1460 cbradney 459
                                /* Item types 3 and 1 are OBSOLETE: CR 2005-02-06
456 fschmid 460
                                case 1:
461
                                case 3:
1460 cbradney 462
                                */
463
                                case PageItem::Polygon:
2877 cbradney 464
                                                if (Item->NamedLStyle.isEmpty())
456 fschmid 465
                                                {
27 Franz 466
                                                        ob = docu->createElement("path");
467
                                                        ob.setAttribute("d", SetClipPath(Item)+"Z");
456 fschmid 468
                                                }
27 Franz 469
                                                else
456 fschmid 470
                                                {
27 Franz 471
                                                        ob = docu->createElement("path");
472
                                                        ob.setAttribute("d", SetClipPath(Item)+"Z");
473
                                                        ob.setAttribute("style", fill);
474
                                                        gr.appendChild(ob);
5781 cbradney 475
                                                        multiLine ml = m_Doc->MLineStyles[Item->NamedLStyle];
31 Franz 476
                                                        for (int it = ml.size()-1; it > -1; it--)
456 fschmid 477
                                                        {
6570 fschmid 478
                                                                if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
479
                                                                {
480
                                                                        ob = docu->createElement("path");
481
                                                                        ob.setAttribute("d", SetClipPath(Item)+"Z");
482
                                                                        ob.setAttribute("style", GetMultiStroke(&ml[it], Item));
483
                                                                        gr.appendChild(ob);
484
                                                                }
27 Franz 485
                                                        }
456 fschmid 486
                                                }
487
                                        break;
1460 cbradney 488
                                case PageItem::ImageFrame:
4546 subik 489
                                                if ((Item->fillColor() != CommonStrings::None) || (Item->GrType != 0))
456 fschmid 490
                                                {
22 Franz 491
                                                        ob = docu->createElement("path");
492
                                                        ob.setAttribute("d", SetClipPath(Item)+"Z");
493
                                                        ob.setAttribute("style", fill);
494
                                                        gr.appendChild(ob);
456 fschmid 495
                                                }
2877 cbradney 496
                                                if ((Item->PicAvail) && (!Item->Pfile.isEmpty()))
456 fschmid 497
                                                {
23 Franz 498
                                                        ob = docu->createElement("clipPath");
22 Franz 499
                                                        ob.setAttribute("id", Clipi+IToStr(ClipCount));
500
                                                        ob.setAttribute("clipPathUnits", "userSpaceOnUse");
24 Franz 501
                                                        ob.setAttribute("clip-rule", "evenodd");
22 Franz 502
                                                        QDomElement cl = docu->createElement("path");
2040 fschmid 503
                                                        if (Item->imageClip.size() != 0)
504
                                                                cl.setAttribute("d", SetClipPathImage(Item)+"Z");
505
                                                        else
506
                                                                cl.setAttribute("d", SetClipPath(Item)+"Z");
22 Franz 507
                                                        ob.appendChild(cl);
508
                                                        gr.appendChild(ob);
2004 fschmid 509
                                                        ScImage img;
5959 jghali 510
                                                        CMSettings cms(m_Doc, Item->IProfile, Item->IRender);
511
                                                        img.LoadPicture(Item->Pfile, cms, Item->UseEmbedded, true, ScImage::RGBProof, 72);
5781 cbradney 512
                                                        img.applyEffect(Item->effectsInUse, m_Doc->PageColors, true);
23 Franz 513
                                                        QFileInfo fi = QFileInfo(Item->Pfile);
5593 avox 514
                                                        img.qImage().save(fi.baseName()+".png", "PNG");
22 Franz 515
                                                        ob = docu->createElement("image");
516
                                                        ob.setAttribute("clip-path", "url(#"+Clipi+IToStr(ClipCount)+")");
23 Franz 517
                                                        ob.setAttribute("xlink:href", fi.baseName()+".png");
318 Franz 518
                                                        ob.setAttribute("x", "0pt");
519
                                                        ob.setAttribute("y", "0pt");
3934 cbradney 520
                                                        ob.setAttribute("width", FToStr(Item->width())+"pt");
521
                                                        ob.setAttribute("height", FToStr(Item->height())+"pt");
22 Franz 522
                                                        ClipCount++;
27 Franz 523
                                                        gr.appendChild(ob);
456 fschmid 524
                                                }
2877 cbradney 525
                                                if (Item->NamedLStyle.isEmpty())
456 fschmid 526
                                                {
27 Franz 527
                                                        ob = docu->createElement("path");
68 Franz 528
                                                        ob.setAttribute("d", SetClipPath(Item)+"Z");
529
                                                        ob.setAttribute("style", "fill:none; "+stroke+" "+strokeW+" "+strokeLC+" "+strokeLJ+" "+strokeDA);
456 fschmid 530
                                                }
27 Franz 531
                                                else
456 fschmid 532
                                                {
5781 cbradney 533
                                                        multiLine ml = m_Doc->MLineStyles[Item->NamedLStyle];
31 Franz 534
                                                        for (int it = ml.size()-1; it > -1; it--)
456 fschmid 535
                                                        {
6570 fschmid 536
                                                                if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
537
                                                                {
538
                                                                        ob = docu->createElement("path");
539
                                                                        ob.setAttribute("d", SetClipPath(Item)+"Z");
540
                                                                        ob.setAttribute("style", "fill:none; "+GetMultiStroke(&ml[it], Item));
541
                                                                        gr.appendChild(ob);
542
                                                                }
27 Franz 543
                                                        }
456 fschmid 544
                                                }
545
                                        break;
1460 cbradney 546
                                case PageItem::PolyLine:
2877 cbradney 547
                                                if (Item->NamedLStyle.isEmpty())
456 fschmid 548
                                                {
27 Franz 549
                                                        ob = docu->createElement("path");
550
                                                        ob.setAttribute("d", SetClipPath(Item));
456 fschmid 551
                                                }
27 Franz 552
                                                else
456 fschmid 553
                                                {
5781 cbradney 554
                                                        multiLine ml = m_Doc->MLineStyles[Item->NamedLStyle];
31 Franz 555
                                                        for (int it = ml.size()-1; it > -1; it--)
456 fschmid 556
                                                        {
6570 fschmid 557
                                                                if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
558
                                                                {
559
                                                                        ob = docu->createElement("path");
560
                                                                        ob.setAttribute("d", SetClipPath(Item));
561
                                                                        ob.setAttribute("style", GetMultiStroke(&ml[it], Item));
562
                                                                        gr.appendChild(ob);
563
                                                                }
27 Franz 564
                                                        }
456 fschmid 565
                                                }
566
                                        break;
1460 cbradney 567
                                case PageItem::TextFrame:
4546 subik 568
                                                if ((Item->fillColor() != CommonStrings::None) || (Item->GrType != 0))
456 fschmid 569
                                                {
21 Franz 570
                                                        ob = docu->createElement("path");
571
                                                        ob.setAttribute("d", SetClipPath(Item)+"Z");
572
                                                        ob.setAttribute("style", fill);
573
                                                        gr.appendChild(ob);
456 fschmid 574
                                                }
21 Franz 575
                                                ob = docu->createElement("text");
5559 avox 576
                                                for (d = 0; d < Item->itemText.length() && ! Item->frameDisplays(d); ++d)
577
                                                        ;
578
                                                for (; d < Item->itemText.length() && Item->frameDisplays(d); ++d)
456 fschmid 579
                                                {
5721 avox 580
                                                        hl = Item->itemText.item(d);
249 Franz 581
                                                        if ((hl->ch == QChar(13)) || (hl->ch == QChar(10)) || (hl->ch == QChar(9)) || (hl->ch == QChar(28)))
21 Franz 582
                                                                continue;
5691 avox 583
                                                        if (hl->glyph.yoffset == 0)
21 Franz 584
                                                                break;
55 Franz 585
                                                        if (hl->ch == QChar(29))
586
                                                                chx = " ";
587
                                                        else
588
                                                                chx = hl->ch;
21 Franz 589
                                                        tp = docu->createElement("tspan");
5691 avox 590
                                                        tp.setAttribute("x", FToStr(hl->glyph.xoffset)+"pt");
591
                                                        tp.setAttribute("y", FToStr(hl->glyph.yoffset)+"pt");
3207 craig 592
                                                        SetTextProps(&tp, hl);
55 Franz 593
                                                        tp1 = docu->createTextNode(chx);
21 Franz 594
                                                        tp.appendChild(tp1);
595
                                                        ob.appendChild(tp);
456 fschmid 596
                                                }
597
                                        break;
1460 cbradney 598
                                case PageItem::Line:
2877 cbradney 599
                                                if (Item->NamedLStyle.isEmpty())
456 fschmid 600
                                                {
27 Franz 601
                                                        ob = docu->createElement("path");
3934 cbradney 602
                                                        ob.setAttribute("d", "M 0 0 L "+FToStr(Item->width())+" 0");
456 fschmid 603
                                                }
27 Franz 604
                                                else
456 fschmid 605
                                                {
5781 cbradney 606
                                                        multiLine ml = m_Doc->MLineStyles[Item->NamedLStyle];
31 Franz 607
                                                        for (int it = ml.size()-1; it > -1; it--)
456 fschmid 608
                                                        {
6570 fschmid 609
                                                                if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
610
                                                                {
611
                                                                        ob = docu->createElement("path");
612
                                                                        ob.setAttribute("d", "M 0 0 L "+FToStr(Item->width())+" 0");
613
                                                                        ob.setAttribute("style", GetMultiStroke(&ml[it], Item));
614
                                                                        gr.appendChild(ob);
615
                                                                }
27 Franz 616
                                                        }
456 fschmid 617
                                                }
618
                                        break;
1460 cbradney 619
                                case PageItem::PathText:
21 Franz 620
                                                if (Item->PoShow)
456 fschmid 621
                                                {
2877 cbradney 622
                                                        if (Item->NamedLStyle.isEmpty())
21 Franz 623
                                                        {
27 Franz 624
                                                                ob = docu->createElement("path");
625
                                                                ob.setAttribute("d", SetClipPath(Item));
626
                                                                gr.appendChild(ob);
456 fschmid 627
                                                        }
27 Franz 628
                                                        else
456 fschmid 629
                                                        {
5781 cbradney 630
                                                                multiLine ml = m_Doc->MLineStyles[Item->NamedLStyle];
31 Franz 631
                                                                for (int it = ml.size()-1; it > -1; it--)
456 fschmid 632
                                                                {
6570 fschmid 633
                                                                        if ((ml[it].Color != CommonStrings::None) && (ml[it].Width != 0))
634
                                                                        {
635
                                                                                ob = docu->createElement("path");
636
                                                                                ob.setAttribute("d", SetClipPath(Item));
637
                                                                                ob.setAttribute("style", GetMultiStroke(&ml[it], Item));
638
                                                                                gr.appendChild(ob);
639
                                                                        }
27 Franz 640
                                                                }
21 Franz 641
                                                        }
456 fschmid 642
                                                }
21 Franz 643
                                                ob = docu->createElement("text");
5559 avox 644
                                                for (d = 0; d < Item->itemText.length() && !Item->frameDisplays(d); ++d)
645
                                                        ;
646
                                                for (; d < Item->itemText.length() && Item->frameDisplays(d); ++d)
456 fschmid 647
                                                {
5721 avox 648
                                                        hl = Item->itemText.item(d);
2955 fschmid 649
                                                        if ((hl->ch == QChar(13)) || (hl->ch == QChar(10)) || (hl->ch == QChar(9)) || (hl->ch == QChar(25)) || (hl->ch == QChar(28)))
21 Franz 650
                                                                continue;
55 Franz 651
                                                        if (hl->ch == QChar(29))
652
                                                                chx = " ";
653
                                                        else
654
                                                                chx = hl->ch;
21 Franz 655
                                                        tp = docu->createElement("tspan");
318 Franz 656
                                                        tp.setAttribute("x", FToStr(hl->PtransX)+"pt");
657
                                                        tp.setAttribute("y", FToStr(hl->PtransY)+"pt");
21 Franz 658
                                                        tp.setAttribute("rotate", hl->PRot);
659
                                                        tp2 = docu->createElement("tspan");
5691 avox 660
                                                        tp2.setAttribute("dx", FToStr(hl->glyph.xoffset)+"pt");
661
                                                        tp2.setAttribute("dy", FToStr(hl->glyph.yoffset)+"pt");
3207 craig 662
                                                        SetTextProps(&tp2, hl);
55 Franz 663
                                                        tp1 = docu->createTextNode(chx);
21 Franz 664
                                                        tp2.appendChild(tp1);
665
                                                        tp.appendChild(tp2);
666
                                                        ob.appendChild(tp);
456 fschmid 667
                                                }
668
                                        break;
2004 fschmid 669
                                default:
670
                                        break;
456 fschmid 671
                                }
21 Franz 672
                                if (Item->GrType != 0)
673
                                        elem->appendChild(defi);
674
                                gr.appendChild(ob);
675
                                elem->appendChild(gr);
676
                        }
456 fschmid 677
                }
21 Franz 678
                Lnr++;
456 fschmid 679
        }
5781 cbradney 680
        m_Doc->setCurrentPage(SavedAct);
21 Franz 681
}
682
 
683
QString SVGExPlug::SetClipPath(PageItem *ite)
684
{
685
        QString tmp = "";
686
        FPoint np, np1, np2;
687
        bool nPath = true;
688
        if (ite->PoLine.size() > 3)
689
                {
690
                for (uint poi=0; poi<ite->PoLine.size()-3; poi += 4)
691
                        {
692
                        if (ite->PoLine.point(poi).x() > 900000)
693
                                {
694
                                tmp += "Z ";
695
                                nPath = true;
696
                                continue;
697
                                }
698
                        if (nPath)
699
                                {
700
                                np = ite->PoLine.point(poi);
701
                                tmp += "M"+FToStr(np.x())+" "+FToStr(np.y())+" ";
702
                                nPath = false;
703
                                }
704
                        np = ite->PoLine.point(poi+1);
705
                        tmp += "C"+FToStr(np.x())+" "+FToStr(np.y())+" ";
706
                        np1 = ite->PoLine.point(poi+3);
707
                        tmp += FToStr(np1.x())+" "+FToStr(np1.y())+" ";
708
                        np2 = ite->PoLine.point(poi+2);
709
                        tmp += FToStr(np2.x())+" "+FToStr(np2.y())+" ";
710
                        }
711
                }
712
        return tmp;
1552 subik 713
}
21 Franz 714
 
2040 fschmid 715
QString SVGExPlug::SetClipPathImage(PageItem *ite)
716
{
717
        QString tmp = "";
718
        FPoint np, np1, np2;
719
        bool nPath = true;
720
        if (ite->imageClip.size() > 3)
721
                {
722
                for (uint poi=0; poi<ite->imageClip.size()-3; poi += 4)
723
                        {
724
                        if (ite->imageClip.point(poi).x() > 900000)
725
                                {
726
                                tmp += "Z ";
727
                                nPath = true;
728
                                continue;
729
                                }
730
                        if (nPath)
731
                                {
732
                                np = ite->imageClip.point(poi);
733
                                tmp += "M"+FToStr(np.x())+" "+FToStr(np.y())+" ";
734
                                nPath = false;
735
                                }
736
                        np = ite->imageClip.point(poi+1);
737
                        tmp += "C"+FToStr(np.x())+" "+FToStr(np.y())+" ";
738
                        np1 = ite->imageClip.point(poi+3);
739
                        tmp += FToStr(np1.x())+" "+FToStr(np1.y())+" ";
740
                        np2 = ite->imageClip.point(poi+2);
741
                        tmp += FToStr(np2.x())+" "+FToStr(np2.y())+" ";
742
                        }
743
                }
744
        return tmp;
745
}
746
 
80 Franz 747
QString SVGExPlug::FToStr(double c)
21 Franz 748
{
749
        QString cc;
750
        return cc.setNum(c);
751
}
752
 
753
QString SVGExPlug::IToStr(int c)
754
{
755
        QString cc;
756
        return cc.setNum(c);
757
}
758
 
5346 mrdocs 759
void SVGExPlug::SetTextProps(QDomElement *tp, ScText *hl)
21 Franz 760
{
5691 avox 761
        int chst = hl->effects() & 127;
762
        if (hl->fillColor() != CommonStrings::None)
763
                tp->setAttribute("fill", SetFarbe(hl->fillColor(), hl->fillShade()));
21 Franz 764
        else
765
                tp->setAttribute("fill", "none");
5691 avox 766
        if ((hl->strokeColor() != CommonStrings::None) && (chst & 4))
68 Franz 767
                {
5691 avox 768
                tp->setAttribute("stroke", SetFarbe(hl->strokeColor(), hl->strokeShade()));
5980 avox 769
                tp->setAttribute("stroke-width", FToStr(hl->font().strokeWidth(hl->fontSize() / 10.0))+"pt");
68 Franz 770
                }
771
        else
772
                tp->setAttribute("stroke", "none");
5691 avox 773
        tp->setAttribute("font-size", (hl->fontSize() / 10.0));
5980 avox 774
        tp->setAttribute("font-family", hl->font().family());
21 Franz 775
        if (chst != 0)
776
                {
777
                if (chst & 64)
778
                        tp->setAttribute("font-variant", "small-caps");
779
                if (chst & 32)
780
                        tp->setAttribute("font-weight", "bold");
781
                if (chst & 16)
782
                        tp->setAttribute("text-decoration", "line-through");
783
                if (chst & 8)
784
                        tp->setAttribute("text-decoration", "underline");
785
                }
786
}
787
 
3207 craig 788
QString SVGExPlug::SetFarbe(QString farbe, int shad)
21 Franz 789
{
5781 cbradney 790
        return m_Doc->PageColors[farbe].getShadeColorProof(shad).name();
21 Franz 791
}
792
 
3207 craig 793
QString SVGExPlug::GetMultiStroke(struct SingleLine *sl, PageItem *Item)
27 Franz 794
{
795
        QString tmp = "fill:none; ";
3207 craig 796
        tmp += "stroke:"+SetFarbe(sl->Color, sl->Shade)+"; ";
1394 cbradney 797
        if (Item->fillTransparency() != 0)
798
                tmp += " stroke-opacity:"+FToStr(1.0 - Item->fillTransparency())+"; ";
318 Franz 799
        tmp += "stroke-width:"+FToStr(sl->Width)+"pt; ";
27 Franz 800
        tmp += "stroke-linecap:";
801
        switch (static_cast<PenCapStyle>(sl->LineEnd))
802
                {
803
                case Qt::FlatCap:
804
                        tmp += "butt;";
805
                        break;
806
                case Qt::SquareCap:
807
                        tmp += "square;";
808
                        break;
809
                case Qt::RoundCap:
810
                        tmp += "round;";
811
                        break;
812
                default:
813
                        tmp += "butt;";
814
                        break;
815
                }
816
        tmp += " stroke-linejoin:";
817
        switch (static_cast<PenJoinStyle>(sl->LineJoin))
818
                {
819
                case Qt::MiterJoin:
820
                        tmp += "miter;";
821
                        break;
822
                case Qt::BevelJoin:
823
                        tmp += "bevel;";
824
                        break;
825
                case Qt::RoundJoin:
826
                        tmp += "round;";
827
                        break;
828
                default:
829
                        tmp += "miter;";
830
                        break;
831
                }
832
        tmp += " stroke-dasharray:";
292 Franz 833
        QString Dt = FToStr(QMAX(2*sl->Width, 1));
834
        QString Da = FToStr(QMAX(6*sl->Width, 1));
27 Franz 835
        switch (static_cast<PenStyle>(sl->Dash))
836
                {
837
                case Qt::SolidLine:
838
                        tmp += "none;";
839
                        break;
840
                case Qt::DashLine:
841
                        tmp += Da+","+Dt+";";
842
                        break;
843
                case Qt::DotLine:
844
                        tmp += Dt+";";
845
                        break;
846
                case Qt::DashDotLine:
847
                        tmp += Da+","+Dt+","+Dt+","+Dt+";";
848
                        break;
849
                case Qt::DashDotDotLine:
850
                        tmp += Da+","+Dt+","+Dt+","+Dt+","+Dt+","+Dt+";";
851
                        break;
852
                default:
853
                        tmp += "none;";
854
                        break;
855
                }
856
        return tmp;
857
}
5697 fschmid 858
#endif
27 Franz 859
 
21 Franz 860
SVGExPlug::~SVGExPlug()
861
{
862
}
3207 craig 863
 
864
#include "svgexplugin.moc"