source: wkhtmltox/trunk/fuentes/src/lib/pdfsettings.cc @ 51

Last change on this file since 51 was 51, checked in by mabarracus, 4 years ago

wip

File size: 12.1 KB
Line 
1// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
2// vi:set ts=4 sts=4 sw=4 noet :
3//
4// Copyright 2010 wkhtmltopdf authors
5//
6// This file is part of wkhtmltopdf.
7//
8// wkhtmltopdf is free software: you can redistribute it and/or modify
9// it under the terms of the GNU Lesser General Public License as published by
10// the Free Software Foundation, either version 3 of the License, or
11// (at your option) any later version.
12//
13// wkhtmltopdf is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16// GNU General Public License for more details.
17//
18// You should have received a copy of the GNU Lesser General Public License
19// along with wkhtmltopdf.  If not, see <http://www.gnu.org/licenses/>.
20
21
22#ifdef _MSC_VER
23#define strcasecmp _stricmp
24#endif
25
26#include "pdfsettings.hh"
27#include "reflect.hh"
28#include <QMap>
29#include <stdexcept>
30
31#include "dllbegin.inc"
32namespace wkhtmltopdf {
33namespace settings {
34
35template<>
36struct DLL_LOCAL ReflectImpl<UnitReal>: public ReflectSimple {
37        UnitReal & ur;
38        ReflectImpl(UnitReal & _): ur(_) {}
39        QString get() {bool d; return unitRealToStr(ur, &d);}
40        void set(const QString & value, bool * ok) {ur = strToUnitReal(value.toUtf8().constData(), ok);}
41};
42
43template<>
44struct DLL_LOCAL ReflectImpl<QPrinter::PageSize>: public ReflectSimple {
45        QPrinter::PageSize & ps;
46        ReflectImpl(QPrinter::PageSize & _): ps(_) {}
47        QString get() {return pageSizeToStr(ps);}
48        void set(const QString & value, bool * ok) {ps = strToPageSize(value.toUtf8().constData(), ok);}
49};
50
51template<>
52struct DLL_LOCAL ReflectImpl<QPrinter::Orientation>: public ReflectSimple {
53        QPrinter::Orientation & o;
54        ReflectImpl(QPrinter::Orientation & _): o(_) {}
55        QString get() {return orientationToStr(o);}
56        void set(const QString & value, bool * ok) {o = strToOrientation(value.toUtf8().constData(), ok);}
57};
58
59template<>
60struct DLL_LOCAL ReflectImpl<QPrinter::PrinterMode>: public ReflectSimple {
61        QPrinter::PrinterMode & m;
62        ReflectImpl(QPrinter::PrinterMode & _): m(_) {}
63        QString get() {return printerModeToStr(m);}
64        void set(const QString & value, bool * ok) {m = strToPrinterMode(value.toUtf8().constData(), ok);}
65};
66
67template<>
68struct DLL_LOCAL ReflectImpl<QPrinter::ColorMode>: public ReflectSimple {
69        QPrinter::ColorMode & m;
70        ReflectImpl(QPrinter::ColorMode & _): m(_) {}
71        QString get() {return colorModeToStr(m);}
72        void set(const QString & value, bool * ok) {m = strToColorMode(value.toUtf8().constData(), ok);}
73};
74
75template<>
76struct DLL_LOCAL ReflectImpl<Margin>: public ReflectClass {
77        ReflectImpl(Margin & c) {
78                WKHTMLTOPDF_REFLECT(top);
79                WKHTMLTOPDF_REFLECT(right);
80                WKHTMLTOPDF_REFLECT(bottom);
81                WKHTMLTOPDF_REFLECT(left);
82        }
83};
84
85template<>
86struct DLL_LOCAL ReflectImpl<Size>: public ReflectClass {
87        ReflectImpl(Size & c) {
88                WKHTMLTOPDF_REFLECT(pageSize);
89                WKHTMLTOPDF_REFLECT(height);
90                WKHTMLTOPDF_REFLECT(width);
91        }
92};
93
94template<>
95struct DLL_LOCAL ReflectImpl<TableOfContent>: public ReflectClass {
96        ReflectImpl(TableOfContent & c) {
97                WKHTMLTOPDF_REFLECT(useDottedLines);
98                WKHTMLTOPDF_REFLECT(captionText);
99                WKHTMLTOPDF_REFLECT(forwardLinks);
100                WKHTMLTOPDF_REFLECT(backLinks);
101                WKHTMLTOPDF_REFLECT(indentation);
102                WKHTMLTOPDF_REFLECT(fontScale);
103        }
104};
105
106template<>
107struct DLL_LOCAL ReflectImpl<PdfGlobal>: public ReflectClass {
108        ReflectImpl(PdfGlobal & c) {
109                WKHTMLTOPDF_REFLECT(size);
110                WKHTMLTOPDF_REFLECT(quiet);
111                WKHTMLTOPDF_REFLECT(useGraphics);
112                WKHTMLTOPDF_REFLECT(resolveRelativeLinks);
113                WKHTMLTOPDF_REFLECT(orientation);
114                WKHTMLTOPDF_REFLECT(colorMode);
115                WKHTMLTOPDF_REFLECT(resolution);
116                WKHTMLTOPDF_REFLECT(dpi);
117                WKHTMLTOPDF_REFLECT(pageOffset);
118                WKHTMLTOPDF_REFLECT(copies);
119                WKHTMLTOPDF_REFLECT(collate);
120                WKHTMLTOPDF_REFLECT(outline);
121                WKHTMLTOPDF_REFLECT(dumpOutline);
122                WKHTMLTOPDF_REFLECT(out);
123                WKHTMLTOPDF_REFLECT(documentTitle);
124                WKHTMLTOPDF_REFLECT(useCompression);
125                WKHTMLTOPDF_REFLECT(margin);
126                WKHTMLTOPDF_REFLECT(imageDPI);
127                WKHTMLTOPDF_REFLECT(imageQuality);
128                WKHTMLTOPDF_REFLECT(load);
129        }
130};
131
132template<>
133struct DLL_LOCAL ReflectImpl<HeaderFooter>: public ReflectClass {
134        ReflectImpl(HeaderFooter & c) {
135                WKHTMLTOPDF_REFLECT(fontSize);
136                WKHTMLTOPDF_REFLECT(fontName);
137                WKHTMLTOPDF_REFLECT(left);
138                WKHTMLTOPDF_REFLECT(right);
139                WKHTMLTOPDF_REFLECT(center);
140                WKHTMLTOPDF_REFLECT(line);
141                WKHTMLTOPDF_REFLECT(htmlUrl);
142                WKHTMLTOPDF_REFLECT(spacing);
143        }
144};
145
146template<>
147struct DLL_LOCAL ReflectImpl<PdfObject>: public ReflectClass {
148        ReflectImpl(PdfObject & c) {
149                WKHTMLTOPDF_REFLECT(toc);
150                WKHTMLTOPDF_REFLECT(page);
151                WKHTMLTOPDF_REFLECT(header);
152                WKHTMLTOPDF_REFLECT(footer);
153                WKHTMLTOPDF_REFLECT(useExternalLinks);
154                WKHTMLTOPDF_REFLECT(useLocalLinks);
155                WKHTMLTOPDF_REFLECT(replacements);
156                WKHTMLTOPDF_REFLECT(produceForms);
157                WKHTMLTOPDF_REFLECT(load);
158                WKHTMLTOPDF_REFLECT(web);
159                WKHTMLTOPDF_REFLECT(includeInOutline);
160                WKHTMLTOPDF_REFLECT(pagesCount);
161                WKHTMLTOPDF_REFLECT(isTableOfContent);
162                WKHTMLTOPDF_REFLECT(tocXsl);
163        }
164};
165
166
167
168/*!
169  \file settings.hh
170  \brief Defines the Settings class
171*/
172DLL_LOCAL QMap<QString, QPrinter::PageSize> pageSizeMap() {
173        QMap<QString, QPrinter::PageSize> res;
174        res["A0"] = QPrinter::A0;
175        res["A1"] = QPrinter::A1;
176        res["A2"] = QPrinter::A2;
177        res["A3"] = QPrinter::A3;
178        res["A4"] = QPrinter::A4;
179        res["A5"] = QPrinter::A5;
180        res["A6"] = QPrinter::A6;
181        res["A7"] = QPrinter::A7;
182        res["A8"] = QPrinter::A8;
183        res["A9"] = QPrinter::A9;
184        res["B0"] = QPrinter::B0;
185        res["B1"] = QPrinter::B1;
186        res["B10"] = QPrinter::B10;
187        res["B2"] = QPrinter::B2;
188        res["B3"] = QPrinter::B3;
189        res["B4"] = QPrinter::B4;
190        res["B5"] = QPrinter::B5;
191        res["B6"] = QPrinter::B6;
192        res["B7"] = QPrinter::B7;
193        res["B8"] = QPrinter::B8;
194        res["B9"] = QPrinter::B9;
195        res["C5E"] = QPrinter::C5E;
196        res["Comm10E"] = QPrinter::Comm10E;
197        res["DLE"] = QPrinter::DLE;
198        res["Executive"] = QPrinter::Executive;
199        res["Folio"] = QPrinter::Folio;
200        res["Ledger"] = QPrinter::Ledger;
201        res["Legal"] = QPrinter::Legal;
202        res["Letter"] = QPrinter::Letter;
203        res["Tabloid"] = QPrinter::Tabloid;
204        return res;
205}
206
207/*!
208  Convert a string to a paper size, basically all thinkable values are allowed.
209  if a unknown value is given A4 is returned
210  \param s The string to convert
211  \param ok If supplied indicates if the conversion was successful
212*/
213QPrinter::PageSize strToPageSize(const char * s, bool * ok) {
214        QMap<QString,QPrinter::PageSize> map = pageSizeMap();
215        for (QMap<QString,QPrinter::PageSize>::const_iterator i=map.begin(); i != map.end(); ++i) {
216                if (i.key().compare(s, Qt::CaseInsensitive) != 0) continue;
217                if (ok) *ok=true;
218                return i.value();
219        }
220        if (ok) *ok = false;
221        return QPrinter::A4;
222}
223
224QString pageSizeToStr(QPrinter::PageSize ps) {
225        QMap<QString,QPrinter::PageSize> map = pageSizeMap();
226        for (QMap<QString,QPrinter::PageSize>::const_iterator i=map.begin(); i != map.end(); ++i) {
227                if (i.value() == ps) return i.key();
228        }
229        return "";
230}
231
232
233/*!
234  Read orientation from a string, possible values are landscape and portrait (case insensitive)
235  \param s The string containing the orientation
236  \param ok If supplied indicates whether the s was valid
237*/
238QPrinter::Orientation strToOrientation(const char * s, bool * ok) {
239        if (ok) *ok = true;
240        if (!strcasecmp(s,"Landscape")) return QPrinter::Landscape;
241        if (!strcasecmp(s,"Portrait")) return QPrinter::Portrait;
242        if (ok) *ok = false;
243        return QPrinter::Portrait;
244}
245
246QString orientationToStr(QPrinter::Orientation o) {
247        return (o == QPrinter::Landscape)?"Landscape":"Portrait";
248}
249
250
251/*!
252  Parse a string describing a distance, into a real number and a unit.
253  \param o Tho string describing the distance
254  \param ok If supplied indicates whether the s was valid
255*/
256UnitReal strToUnitReal(const char * o, bool * ok) {
257        qreal s=1.0; //Since not all units are provided by qt, we use this variable to scale
258        //Them into units that are.
259        QPrinter::Unit u=QPrinter::Millimeter;
260        //Skip the real number part
261        int i=0;
262        while ('0' <= o[i]  && o[i] <= '9') ++i;
263        if (o[i] == '.' || o[i] == '.') ++i;
264        while ('0' <= o[i]  && o[i] <= '9') ++i;
265        //Try to match the unit used
266        if (!strcasecmp(o+i,"") || !strcasecmp(o+i,"mm") || !strcasecmp(o+i,"millimeter")) {
267                u=QPrinter::Millimeter;
268        } else if (!strcasecmp(o+i,"cm") || !strcasecmp(o+i,"centimeter")) {
269                u=QPrinter::Millimeter;
270                s=10.0; //1cm=10mm
271        } else if (!strcasecmp(o+i,"m") || !strcasecmp(o+i,"meter")) {
272                u=QPrinter::Millimeter;
273                s=1000.0; //1m=1000m
274        } else if (!strcasecmp(o+i,"didot"))
275                u=QPrinter::Didot; //Todo is there a short for didot??
276        else if (!strcasecmp(o+i,"inch") || !strcasecmp(o+i,"in"))
277                u=QPrinter::Inch;
278        else if (!strcasecmp(o+i,"pica") || !strcasecmp(o+i,"pc"))
279                u=QPrinter::Pica;
280        else if (!strcasecmp(o+i,"cicero"))
281                u=QPrinter::Cicero;
282        else if (!strcasecmp(o+i,"pixel") || !strcasecmp(o+i,"px"))
283                u=QPrinter::DevicePixel;
284        else if (!strcasecmp(o+i,"point") || !strcasecmp(o+i,"pt"))
285                u=QPrinter::Point;
286        else {
287                if (ok) *ok=false;
288                return UnitReal(QString(o).left(i).toDouble()*s, u);
289        }
290        return UnitReal(QString(o).left(i).toDouble(ok)*s, u);
291}
292
293QString unitRealToStr(const UnitReal & ur, bool * ok) {
294        QString c;
295        if (ur.first == -1) {
296                if (ok) *ok=false;
297                return "";
298        }
299        if (ok) *ok=true;
300        switch (ur.second) {
301        case QPrinter::Didot: c = "didot"; break;
302        case QPrinter::Inch: c = "in"; break;
303        case QPrinter::Pica: c = "pica"; break;
304        case QPrinter::DevicePixel: c = "px"; break;
305        case QPrinter::Point: c = "pt"; break;
306        case QPrinter::Millimeter: c = "mm"; break;
307        default:
308                if (ok) *ok=false; break;
309        }
310        return QString("%1%2").arg(ur.first).arg(c);
311}
312
313QPrinter::PrinterMode strToPrinterMode(const char * s, bool * ok) {
314        if (ok) *ok=true;
315        if (!strcasecmp(s,"screen")) return QPrinter::ScreenResolution;
316        if (!strcasecmp(s,"printer")) return QPrinter::PrinterResolution;
317        if (!strcasecmp(s,"high")) return QPrinter::HighResolution;
318        *ok=false;
319        return QPrinter::HighResolution;
320}
321
322QString printerModeToStr(QPrinter::PrinterMode o) {
323        switch (o) {
324        case QPrinter::ScreenResolution: return "screen";
325        case QPrinter::PrinterResolution: return "printer";
326        case QPrinter::HighResolution: return "high";
327        }
328        return QString();
329}
330
331QPrinter::ColorMode strToColorMode(const char * s, bool * ok) {
332        if (ok) *ok=true;
333        if (!strcasecmp(s,"color"))     return QPrinter::Color;
334        if (!strcasecmp(s,"grayscale")) return QPrinter::GrayScale;
335        *ok=false;
336        return QPrinter::Color;
337}
338
339QString colorModeToStr(QPrinter::ColorMode o) {
340        switch (o) {
341        case QPrinter::Color: return "color";
342        case QPrinter::GrayScale: return "grayscale";
343        }
344        return QString();
345}
346
347Size::Size():
348        pageSize(QPrinter::A4),
349        height(UnitReal(-1,QPrinter::Millimeter)),
350        width(UnitReal(-1,QPrinter::Millimeter)) {}
351
352HeaderFooter::HeaderFooter():
353        fontSize(12),
354        fontName("Arial"),
355        left(""),
356        right(""),
357        center(""),
358        line(false),
359        htmlUrl(""),
360        spacing(0.0) {}
361
362Margin::Margin():
363    top(UnitReal(-1,QPrinter::Millimeter)),
364        right(UnitReal(10,QPrinter::Millimeter)),
365    bottom(UnitReal(-1,QPrinter::Millimeter)),
366        left(UnitReal(10,QPrinter::Millimeter)) {}
367
368PdfGlobal::PdfGlobal():
369        quiet(false),
370        useGraphics(false),
371        resolveRelativeLinks(true),
372        orientation(QPrinter::Portrait),
373        colorMode(QPrinter::Color),
374        resolution(QPrinter::HighResolution),
375        dpi(-1),
376        pageOffset(0),
377        copies(1),
378        collate(true),
379        outline(true),
380        outlineDepth(4),
381        dumpOutline(""),
382        out(""),
383        documentTitle(""),
384        useCompression(true),
385        viewportSize(""),
386        imageDPI(600),
387        imageQuality(94){};
388
389TableOfContent::TableOfContent():
390        useDottedLines(true),
391        captionText("Table of Contents"),
392        forwardLinks(true),
393        backLinks(false),
394        indentation("1em"),
395        fontScale(0.8f) {}
396
397PdfObject::PdfObject():
398        useExternalLinks(true),
399        useLocalLinks(true),
400        produceForms(false),
401        includeInOutline(true),
402        pagesCount(true),
403        isTableOfContent(false),
404        tocXsl("") {};
405
406QString PdfGlobal::get(const char * name) {
407        ReflectImpl<PdfGlobal> impl(*this);
408        return impl.get(name);
409}
410
411bool PdfGlobal::set(const char * name, const QString & value) {
412        ReflectImpl<PdfGlobal> impl(*this);
413        return impl.set(name, value);
414}
415
416QString PdfObject::get(const char * name) {
417        ReflectImpl<PdfObject> impl(*this);
418        return impl.get(name);
419}
420
421bool PdfObject::set(const char * name, const QString & value) {
422        ReflectImpl<PdfObject> impl(*this);
423        return impl.set(name, value);
424}
425
426}
427}
Note: See TracBrowser for help on using the repository browser.