← Back to branch summary

~ubuntu-branches/ubuntu/saucy/emscripten/saucy-proposed

« back to all changes in this revision

Viewing changes to tests/poppler/qt4/src/poppler-ps-converter.cc

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/poppler/qt4/src/poppler-ps-converter.cc
 
1
/* poppler-ps-converter.cc: qt interface to poppler
 
2
 * Copyright (C) 2007, 2009, 2010, Albert Astals Cid <aacid@kde.org>
 
3
 * Copyright (C) 2008, Pino Toscano <pino@kde.org>
 
4
 * Copyright (C) 2010 Hib Eris <hib@hiberis.nl>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2, or (at your option)
 
9
 * any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 
19
 */
 
20
 
 
21
#include "poppler-qt4.h"
 
22
 
 
23
#include "poppler-private.h"
 
24
#include "poppler-converter-private.h"
 
25
 
 
26
#include "PSOutputDev.h"
 
27
 
 
28
static void outputToQIODevice(void *stream, char *data, int len)
 
29
{
 
30
        static_cast<QIODevice*>(stream)->write(data, len);
 
31
}
 
32
 
 
33
namespace Poppler {
 
34
 
 
35
class PSConverterPrivate : public BaseConverterPrivate
 
36
{
 
37
        public:
 
38
                PSConverterPrivate();
 
39
 
 
40
                QList<int> pageList;
 
41
                QString title;
 
42
                double hDPI;
 
43
                double vDPI;
 
44
                int rotate;
 
45
                int paperWidth;
 
46
                int paperHeight;
 
47
                int marginRight;
 
48
                int marginBottom;
 
49
                int marginLeft;
 
50
                int marginTop;
 
51
                PSConverter::PSOptions opts;
 
52
                void (* pageConvertedCallback)(int page, void *payload);
 
53
                void *pageConvertedPayload;
 
54
};
 
55
 
 
56
PSConverterPrivate::PSConverterPrivate()
 
57
        : BaseConverterPrivate(),
 
58
        hDPI(72), vDPI(72), rotate(0), paperWidth(-1), paperHeight(-1),
 
59
        marginRight(0), marginBottom(0), marginLeft(0), marginTop(0),
 
60
        opts(PSConverter::Printing), pageConvertedCallback(0),
 
61
        pageConvertedPayload(0)
 
62
{
 
63
}
 
64
 
 
65
 
 
66
PSConverter::PSConverter(DocumentData *document)
 
67
        : BaseConverter(*new PSConverterPrivate())
 
68
{
 
69
        Q_D(PSConverter);
 
70
        d->document = document;
 
71
}
 
72
 
 
73
PSConverter::~PSConverter()
 
74
{
 
75
}
 
76
 
 
77
void PSConverter::setPageList(const QList<int> &pageList)
 
78
{
 
79
        Q_D(PSConverter);
 
80
        d->pageList = pageList;
 
81
}
 
82
 
 
83
void PSConverter::setTitle(const QString &title)
 
84
{
 
85
        Q_D(PSConverter);
 
86
        d->title = title;
 
87
}
 
88
 
 
89
void PSConverter::setHDPI(double hDPI)
 
90
{
 
91
        Q_D(PSConverter);
 
92
        d->hDPI = hDPI;
 
93
}
 
94
 
 
95
void PSConverter::setVDPI(double vDPI)
 
96
{
 
97
        Q_D(PSConverter);
 
98
        d->vDPI = vDPI;
 
99
}
 
100
 
 
101
void PSConverter::setRotate(int rotate)
 
102
{
 
103
        Q_D(PSConverter);
 
104
        d->rotate = rotate;
 
105
}
 
106
 
 
107
void PSConverter::setPaperWidth(int paperWidth)
 
108
{
 
109
        Q_D(PSConverter);
 
110
        d->paperWidth = paperWidth;
 
111
}
 
112
 
 
113
void PSConverter::setPaperHeight(int paperHeight)
 
114
{
 
115
        Q_D(PSConverter);
 
116
        d->paperHeight = paperHeight;
 
117
}
 
118
 
 
119
void PSConverter::setRightMargin(int marginRight)
 
120
{
 
121
        Q_D(PSConverter);
 
122
        d->marginRight = marginRight;
 
123
}
 
124
 
 
125
void PSConverter::setBottomMargin(int marginBottom)
 
126
{
 
127
        Q_D(PSConverter);
 
128
        d->marginBottom = marginBottom;
 
129
}
 
130
 
 
131
void PSConverter::setLeftMargin(int marginLeft)
 
132
{
 
133
        Q_D(PSConverter);
 
134
        d->marginLeft = marginLeft;
 
135
}
 
136
 
 
137
void PSConverter::setTopMargin(int marginTop)
 
138
{
 
139
        Q_D(PSConverter);
 
140
        d->marginTop = marginTop;
 
141
}
 
142
 
 
143
void PSConverter::setStrictMargins(bool strictMargins)
 
144
{
 
145
        Q_D(PSConverter);
 
146
        if (strictMargins)
 
147
                d->opts |= StrictMargins;
 
148
        else
 
149
                d->opts &= ~StrictMargins;
 
150
}
 
151
 
 
152
void PSConverter::setForceRasterize(bool forceRasterize)
 
153
{
 
154
        Q_D(PSConverter);
 
155
        if (forceRasterize)
 
156
                d->opts |= ForceRasterization;
 
157
        else
 
158
                d->opts &= ~ForceRasterization;
 
159
}
 
160
 
 
161
void PSConverter::setPSOptions(PSConverter::PSOptions options)
 
162
{
 
163
        Q_D(PSConverter);
 
164
        d->opts = options;
 
165
}
 
166
 
 
167
PSConverter::PSOptions PSConverter::psOptions() const
 
168
{
 
169
        Q_D(const PSConverter);
 
170
        return d->opts;
 
171
}
 
172
 
 
173
void PSConverter::setPageConvertedCallback(void (* callback)(int page, void *payload), void *payload)
 
174
{
 
175
        Q_D(PSConverter);
 
176
        d->pageConvertedCallback = callback;
 
177
        d->pageConvertedPayload = payload;
 
178
}
 
179
 
 
180
bool PSConverter::convert()
 
181
{
 
182
        Q_D(PSConverter);
 
183
        d->lastError = NoError;
 
184
 
 
185
        Q_ASSERT(!d->pageList.isEmpty());
 
186
        Q_ASSERT(d->paperWidth != -1);
 
187
        Q_ASSERT(d->paperHeight != -1);
 
188
        
 
189
        if (d->document->locked)
 
190
        {
 
191
                d->lastError = FileLockedError;
 
192
                return false;
 
193
        }
 
194
        
 
195
        QIODevice *dev = d->openDevice();
 
196
        if (!dev)
 
197
        {
 
198
                d->lastError = OpenOutputError;
 
199
                return false;
 
200
        }
 
201
 
 
202
        QByteArray pstitle8Bit = d->title.toLocal8Bit();
 
203
        char* pstitlechar;
 
204
        if (!d->title.isEmpty()) pstitlechar = pstitle8Bit.data();
 
205
        else pstitlechar = 0;
 
206
        
 
207
        PSOutputDev *psOut = new PSOutputDev(outputToQIODevice, dev,
 
208
                                             pstitlechar,
 
209
                                             d->document->doc,
 
210
                                             d->document->doc->getXRef(),
 
211
                                             d->document->doc->getCatalog(),
 
212
                                             1,
 
213
                                             d->document->doc->getNumPages(),
 
214
                                             psModePS,
 
215
                                             d->paperWidth,
 
216
                                             d->paperHeight,
 
217
                                             gFalse,
 
218
                                             d->marginLeft,
 
219
                                             d->marginBottom,
 
220
                                             d->paperWidth - d->marginRight,
 
221
                                             d->paperHeight - d->marginTop,
 
222
                                             (d->opts & ForceRasterization));
 
223
        
 
224
        if (d->opts & StrictMargins)
 
225
        {
 
226
                double xScale = ((double)d->paperWidth - (double)d->marginLeft - (double)d->marginRight) / (double)d->paperWidth;
 
227
                double yScale = ((double)d->paperHeight - (double)d->marginBottom - (double)d->marginTop) / (double)d->paperHeight;
 
228
                psOut->setScale(xScale, yScale);
 
229
        }
 
230
        
 
231
        if (psOut->isOk())
 
232
        {
 
233
                GBool isPrinting = (d->opts & Printing) ? gTrue : gFalse;
 
234
                foreach(int page, d->pageList)
 
235
                {
 
236
                        d->document->doc->displayPage(psOut, page, d->hDPI, d->vDPI, d->rotate, gFalse, gTrue, isPrinting);
 
237
                        if (d->pageConvertedCallback)
 
238
                                (*d->pageConvertedCallback)(page, d->pageConvertedPayload);
 
239
                }
 
240
                delete psOut;
 
241
                d->closeDevice();
 
242
                return true;
 
243
        }
 
244
        else
 
245
        {
 
246
                delete psOut;
 
247
                d->closeDevice();
 
248
                return false;
 
249
        }
 
250
}
 
251
 
 
252
}