Subversion Repositories Scribus

Rev

Rev 17163 | Rev 18921 | 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
*/
3165 fschmid 7
/***************************************************************************
8
                          preview.cpp  -  description
9
                             -------------------
10
    begin                : Sun Jun 1 08:00:00 CEST 2003
11
    copyright            : (C) 2003 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
 ***************************************************************************/
23
#include "preview.h"
9988 fschmid 24
 
25
#include <QImage>
8567 jghali 26
#include <QApplication>
27
#include <QDesktopWidget>
9988 fschmid 28
#include <QHBoxLayout>
29
#include <QVBoxLayout>
30
#include <QSpacerItem>
31
#include <QGroupBox>
32
#include <QHeaderView>
33
#include <QTableWidget>
34
#include <QTableWidgetItem>
8501 cbradney 35
#include <QLabel>
9988 fschmid 36
#include <QScrollArea>
37
#include <QPushButton>
38
#include <QComboBox>
8501 cbradney 39
#include <QPixmap>
9988 fschmid 40
#include <QCursor>
41
#include <QPainter>
42
#include <QColor>
43
#include <QToolTip>
44
#include <QFile>
45
#include <QTextStream>
13153 fschmid 46
#include <QSpinBox>
9988 fschmid 47
 
3165 fschmid 48
#include <cstdlib>
15013 jghali 49
#include <algorithm>
50
 
3165 fschmid 51
#include "pslib.h"
52
#include "checkDocument.h"
5781 cbradney 53
#include "cmsettings.h"
3165 fschmid 54
#include "prefsfile.h"
55
#include "prefscontext.h"
3252 craig 56
#include "prefsmanager.h"
3165 fschmid 57
#include "prefstable.h"
58
#include "util.h"
10200 cbradney 59
#include "util_icon.h"
3262 cbradney 60
#include "sccolor.h"
3167 fschmid 61
#include "scribusview.h"
62
#include "scribusdoc.h"
4194 fschmid 63
#include "scpaths.h"
3252 craig 64
#include "pageselector.h"
10212 cbradney 65
#include "util_printer.h"
66
#include "util_ghostscript.h"
9622 jghali 67
#include "sccolorengine.h"
10947 jghali 68
#include "scribuscore.h"
3165 fschmid 69
 
4361 cbradney 70
#if defined(_WIN32)
10967 jghali 71
#include "scprintengine_gdi.h"
4361 cbradney 72
#endif
73
 
3234 fschmid 74
extern bool printDinUse;
75
 
10947 jghali 76
PPreview::PPreview( QWidget* parent, ScribusView *vin, ScribusDoc *docu, QString printer, PrintEngine engine ) : QDialog( parent )
3165 fschmid 77
{
9988 fschmid 78
        setModal(true);
79
        setWindowIcon(QIcon(loadIcon ( "AppIcon.png" )));
4069 craig 80
        Q_ASSERT(!docu->masterPageMode());
3165 fschmid 81
        prefsManager=PrefsManager::instance();
82
        QString tmp;
10947 jghali 83
        postscriptPreview = usePostscriptPreview(printer, engine);
4361 cbradney 84
        QString caption = tr("Print Preview");
85
#ifdef _WIN32
86
        if (postscriptPreview)
12804 cbradney 87
                caption += " (PostScript)";
4361 cbradney 88
        else
89
                caption += " (GDI)";
90
#endif
9988 fschmid 91
        setWindowTitle( caption );
3167 fschmid 92
        doc = docu;
93
        view = vin;
10947 jghali 94
        HavePngAlpha = ScCore->havePNGAlpha();
95
        HaveTiffSep  = postscriptPreview ? ScCore->haveTIFFSep() : false;
3165 fschmid 96
        APage = -1;
97
        CMode = false;
6008 jghali 98
        GsAl = false;
3165 fschmid 99
        Trans = false;
100
        GMode = true;
6690 fschmid 101
        mHor = false;
102
        mVer = false;
103
        fClip = false;
104
        fSpot = true;
105
        fGray = false;
106
        fICC = false;
3172 subik 107
        scaleFactor = 1.0;
3173 fschmid 108
        SMode = 1;
5542 fschmid 109
        getNumericGSVersion(GsMajor, GsMinor);
9988 fschmid 110
        PLayout = new QVBoxLayout(this);
111
        PLayout->setMargin(0);
112
        PLayout->setSpacing(0);
6690 fschmid 113
        int tbWidth = 0;
9988 fschmid 114
        Layout5 = new QHBoxLayout;
6690 fschmid 115
        Layout5->setSpacing(3);
116
        Layout5->setMargin(0);
9988 fschmid 117
        Anzeige = new QScrollArea(this);
118
        Anzeige->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
6690 fschmid 119
        Layout5->addWidget(Anzeige);
9988 fschmid 120
        settingsBarLayout = new QVBoxLayout;
6690 fschmid 121
        settingsBarLayout->setSpacing(3);
122
        settingsBarLayout->setMargin(0);
9988 fschmid 123
        devTitle = new QGroupBox( this );
124
        devTitle->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
6756 fschmid 125
        devTitle->setTitle( tr( "Display Settings" ) );
9988 fschmid 126
        Layout2 = new QVBoxLayout( devTitle );
127
        Layout2->setSpacing(5);
128
        Layout2->setMargin(5);
6690 fschmid 129
        Layout2->setAlignment( Qt::AlignTop );
9988 fschmid 130
        AntiAlias = new QCheckBox(devTitle);
6008 jghali 131
        AntiAlias->setText( tr("Enable &Antialiasing"));
132
        AntiAlias->setChecked( postscriptPreview ? prefsManager->appPrefs.PrPr_AntiAliasing : false);
133
        AntiAlias->setEnabled( postscriptPreview );
134
        Layout2->addWidget(AntiAlias);
9988 fschmid 135
        AliasTr = new QCheckBox(devTitle);
6008 jghali 136
        AliasTr->setText( tr("Display Trans&parency"));
137
        AliasTr->setChecked(prefsManager->appPrefs.PrPr_Transparency);
138
        AliasTr->setEnabled( postscriptPreview );
139
        Layout2->addWidget(AliasTr);
9988 fschmid 140
        EnableCMYK = new QCheckBox(devTitle);
5343 cbradney 141
        EnableCMYK->setText( tr("&Display CMYK"));
142
        EnableCMYK->setChecked( postscriptPreview ? prefsManager->appPrefs.PrPr_Mode : false);
143
        EnableCMYK->setEnabled( postscriptPreview );
6690 fschmid 144
        Layout2->addWidget(EnableCMYK);
10947 jghali 145
        if (HaveTiffSep)
3261 fschmid 146
        {
147
                ColorList usedSpots;
148
                doc->getUsedColors(usedSpots, true);
149
                QStringList spots = usedSpots.keys();
9988 fschmid 150
 
151
                Table = new QTableWidget(spots.count()+4, 2, devTitle );
13153 fschmid 152
                inkMax = (spots.count()+4) * 255;
9988 fschmid 153
                Table->setHorizontalHeaderItem(0, new QTableWidgetItem(QIcon(loadIcon("16/show-object.png")), ""));
154
                Table->setHorizontalHeaderItem(1, new QTableWidgetItem( tr("Separation Name")));
155
                QHeaderView *header = Table->horizontalHeader();
156
                header->setStretchLastSection(true);
157
                header->setMovable(false);
13157 fschmid 158
//              header->setClickable(false);
9988 fschmid 159
                header->setResizeMode(QHeaderView::Fixed);
3261 fschmid 160
                Table->setColumnWidth(0, 24);
161
                Table->verticalHeader()->hide();
9988 fschmid 162
                Table->setSelectionMode( QAbstractItemView::NoSelection );
163
                Table->setEditTriggers(QAbstractItemView::NoEditTriggers);
164
                Table->setFocusPolicy(Qt::NoFocus);
3261 fschmid 165
                flagsVisible.clear();
9988 fschmid 166
                Table->setItem(0, 1, new QTableWidgetItem( tr("Cyan")));
167
                QCheckBox *cp = new QCheckBox(this);
168
                cp->setFocusPolicy(Qt::NoFocus);
3261 fschmid 169
                connect(cp, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
170
                Table->setCellWidget(0, 0, cp);
12050 fschmid 171
                cp->setChecked(prefsManager->appPrefs.PrPr_C);
3261 fschmid 172
                flagsVisible.insert("Cyan", cp);
9988 fschmid 173
                Table->setItem(1, 1, new QTableWidgetItem( tr("Magenta")));
174
                cp = new QCheckBox(this);
175
                cp->setFocusPolicy(Qt::NoFocus);
3261 fschmid 176
                connect(cp, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
177
                Table->setCellWidget(1, 0, cp);
12050 fschmid 178
                cp->setChecked(prefsManager->appPrefs.PrPr_M);
3261 fschmid 179
                flagsVisible.insert("Magenta", cp);
9988 fschmid 180
                Table->setItem(2, 1, new QTableWidgetItem( tr("Yellow")));
181
                cp = new QCheckBox(this);
182
                cp->setFocusPolicy(Qt::NoFocus);
3261 fschmid 183
                connect(cp, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
184
                Table->setCellWidget(2, 0, cp);
12050 fschmid 185
                cp->setChecked(prefsManager->appPrefs.PrPr_Y);
3261 fschmid 186
                flagsVisible.insert("Yellow", cp);
9988 fschmid 187
                Table->setItem(3, 1, new QTableWidgetItem( tr("Black")));
188
                cp = new QCheckBox(this);
189
                cp->setFocusPolicy(Qt::NoFocus);
3261 fschmid 190
                connect(cp, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
191
                Table->setCellWidget(3, 0, cp);
12050 fschmid 192
                cp->setChecked(prefsManager->appPrefs.PrPr_K);
3261 fschmid 193
                flagsVisible.insert("Black", cp);
8567 jghali 194
                for (int sp = 0; sp < spots.count(); ++sp)
3261 fschmid 195
                {
9988 fschmid 196
                        Table->setItem(sp+4, 1, new QTableWidgetItem(spots[sp]));
197
                        cp = new QCheckBox(this);
198
                        cp->setFocusPolicy(Qt::NoFocus);
3261 fschmid 199
                        connect(cp, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
200
                        Table->setCellWidget(sp+4, 0, cp);
12050 fschmid 201
                        cp->setChecked(true);
3261 fschmid 202
                        flagsVisible.insert(spots[sp], cp);
203
                }
6690 fschmid 204
                Layout2->addWidget(Table);
4046 fschmid 205
                tbWidth = Table->columnWidth(1);
13153 fschmid 206
 
207
                EnableInkCover = new QCheckBox(devTitle);
208
                EnableInkCover->setText( tr("Display Ink Coverage"));
209
                EnableInkCover->setChecked(prefsManager->appPrefs.PrPr_InkCoverage);
210
                EnableInkCover->setEnabled( postscriptPreview );
211
                Layout2->addWidget(EnableInkCover);
212
                connect(EnableInkCover, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
213
                Layout7 = new QHBoxLayout;
214
                Layout7->setSpacing(3);
215
                Layout7->setMargin(0);
216
                ThresLabel = new QLabel( tr("Threshold:"), devTitle);
217
                Layout7->addWidget(ThresLabel);
218
                CoverThresholdValue = new QSpinBox(devTitle);
219
                CoverThresholdValue->setSuffix( tr(" %"));
220
                CoverThresholdValue->setMaximum(600);
13173 fschmid 221
                CoverThresholdValue->setMinimum(0);
13153 fschmid 222
                CoverThresholdValue->setSingleStep(10);
13173 fschmid 223
                CoverThresholdValue->setSpecialValueText( tr("None"));
13153 fschmid 224
                CoverThresholdValue->setValue(prefsManager->appPrefs.PrPr_InkThreshold);
13157 fschmid 225
                if ((EnableCMYK->isChecked()) && (EnableInkCover->isChecked()))
226
                        CoverThresholdValue->setEnabled(true);
227
                else
228
                        CoverThresholdValue->setEnabled(false);
13153 fschmid 229
                connect(CoverThresholdValue, SIGNAL(valueChanged(int)), this, SLOT(ToggleCMYK_Colour()));
230
                Layout7->addWidget(CoverThresholdValue);
231
                Layout2->addLayout(Layout7);
13157 fschmid 232
                connect(Table, SIGNAL(cellDoubleClicked(int, int)), this, SLOT(doSpotTable(int)));
233
                connect(header, SIGNAL(sectionClicked(int)), this, SLOT(toggleAllfromHeader()));
3261 fschmid 234
        }
10947 jghali 235
        else
236
        {
237
                EnableCMYK_C = new QCheckBox(devTitle);
238
                EnableCMYK_C->setText( tr("&C"));
239
                EnableCMYK_C->setChecked(postscriptPreview ? prefsManager->appPrefs.PrPr_C : true);
240
                EnableCMYK_C->setEnabled(postscriptPreview);
241
                Layout2->addWidget(EnableCMYK_C);
242
                EnableCMYK_M = new QCheckBox(devTitle);
243
                EnableCMYK_M->setText( tr("&M"));
244
                EnableCMYK_M->setChecked(postscriptPreview ? prefsManager->appPrefs.PrPr_M : true);
245
                EnableCMYK_M->setEnabled(postscriptPreview);
246
                Layout2->addWidget(EnableCMYK_M);
247
                EnableCMYK_Y = new QCheckBox(devTitle);
248
                EnableCMYK_Y->setText( tr("&Y"));
249
                EnableCMYK_Y->setChecked(postscriptPreview ? prefsManager->appPrefs.PrPr_Y : true);
250
                EnableCMYK_Y->setEnabled(postscriptPreview);
251
                Layout2->addWidget(EnableCMYK_Y);
252
                EnableCMYK_K = new QCheckBox(devTitle);
253
                EnableCMYK_K->setText( tr("&K"));
254
                EnableCMYK_K->setChecked(postscriptPreview ? prefsManager->appPrefs.PrPr_K : true);
255
                EnableCMYK_K->setEnabled(postscriptPreview);
256
                Layout2->addWidget(EnableCMYK_K);
257
        }
258
 
6690 fschmid 259
        settingsBarLayout->addWidget(devTitle);
9988 fschmid 260
        jobTitle = new QGroupBox( this );
261
        jobTitle->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
15215 cbradney 262
        jobTitle->setTitle( tr( "Preview Settings" ) );
9988 fschmid 263
        Layout1 = new QVBoxLayout( jobTitle );
264
        Layout1->setSpacing( 5 );
265
        Layout1->setMargin( 5 );
6690 fschmid 266
        Layout1->setAlignment( Qt::AlignTop );
267
 
9988 fschmid 268
        MirrorHor = new QCheckBox( tr( "Mirror Page(s) Horizontal" ), jobTitle );
6690 fschmid 269
        Layout1->addWidget( MirrorHor );
270
 
9988 fschmid 271
        MirrorVert = new QCheckBox( tr( "Mirror Page(s) Vertical" ), jobTitle );
6690 fschmid 272
        Layout1->addWidget( MirrorVert );
273
 
12899 fschmid 274
        ClipMarg = new QCheckBox( tr( "Clip to Printer Margins" ), jobTitle );
6690 fschmid 275
        Layout1->addWidget( ClipMarg );
276
 
9988 fschmid 277
        useGray = new QCheckBox( tr("Print in Grayscale"), jobTitle);
6690 fschmid 278
        Layout1->addWidget(useGray);
279
 
9988 fschmid 280
        EnableGCR = new QCheckBox( tr("&Under Color Removal"), jobTitle);
6690 fschmid 281
        Layout1->addWidget(EnableGCR);
282
 
9988 fschmid 283
        spotColors = new QCheckBox( tr( "Convert Spot Colors" ), jobTitle );
6690 fschmid 284
        Layout1->addWidget( spotColors );
285
 
10435 cbradney 286
        UseICC = new QCheckBox( tr( "Apply Color Profiles" ), jobTitle );
6690 fschmid 287
        Layout1->addWidget( UseICC );
288
        if (!doc->HasCMS)
289
                UseICC->setEnabled(false);
290
 
291
        settingsBarLayout->addWidget(jobTitle);
292
        QSpacerItem* spacerC = new QSpacerItem( 5, 5, QSizePolicy::Minimum, QSizePolicy::Expanding );
293
        settingsBarLayout->addItem( spacerC );
294
        Layout5->addLayout(settingsBarLayout);
295
        PLayout->addLayout(Layout5);
296
 
9988 fschmid 297
        Layout6 = new QHBoxLayout;
3168 fschmid 298
        Layout6->setSpacing(0);
12508 cbradney 299
        Layout6->setMargin(6);
3172 subik 300
        /* scaling */
9988 fschmid 301
        scaleLabel = new QLabel( tr("Scaling:"), this);
11940 subik 302
        // NOTE: Be careful when you change scaleBox item order.
303
        // There is an index order related check in the resizeEvent().
304
        // resizeEvent() will re-create preview when is one of "Fit to ..."
305
        // options in use. - 20080204 PV
9988 fschmid 306
        scaleBox = new QComboBox(this);
3173 fschmid 307
        scaleBox->setEditable(false);
8567 jghali 308
        scaleBox->setFocusPolicy(Qt::NoFocus);
10553 fschmid 309
        scaleBox->addItem("50%");
310
        scaleBox->addItem("100%");
311
        scaleBox->addItem("150%");
312
        scaleBox->addItem("200%");
313
        scaleBox->addItem( tr("Fit to Width"));
314
        scaleBox->addItem( tr("Fit to Height"));
315
        scaleBox->addItem( tr("Fit to Page"));
316
        scaleBox->setCurrentIndex(1);
3172 subik 317
        Layout6->addWidget(scaleLabel);
318
        Layout6->addWidget(scaleBox);
9988 fschmid 319
        QSpacerItem* spacer = new QSpacerItem( 2, 2, QSizePolicy::Expanding, QSizePolicy::Minimum );
3168 fschmid 320
        Layout6->addItem( spacer );
5343 cbradney 321
        PGSel = new PageSelector(this, doc->DocPages.count());
10553 fschmid 322
        PGSel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
5343 cbradney 323
        Layout6->addWidget(PGSel);
9988 fschmid 324
        QSpacerItem* spacer2 = new QSpacerItem( 2, 2, QSizePolicy::Expanding, QSizePolicy::Minimum );
5343 cbradney 325
        Layout6->addItem( spacer2 );
9988 fschmid 326
        closeButton = new QPushButton( tr("Close"), this);
3570 cbradney 327
        closeButton->setAutoDefault(false);
3488 avox 328
        Layout6->addWidget( closeButton );
9988 fschmid 329
        printButton = new QPushButton( tr("Print..."), this );
3570 cbradney 330
        printButton->setAutoDefault(false);    
3234 fschmid 331
        printButton->setEnabled(!printDinUse);
3230 fschmid 332
        Layout6->addWidget( printButton );
3168 fschmid 333
        PLayout->addLayout(Layout6);
6690 fschmid 334
        setValues();
9988 fschmid 335
        Anz = new QLabel(this);
336
        Anz->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
11124 fschmid 337
//      APage = doc->currentPage()->pageNr();
338
        Anz->setPixmap(CreatePreview(doc->currentPage()->pageNr(), 72));
339
        Anz->resize(Anz->pixmap()->size());
9988 fschmid 340
        Anzeige->setWidget(Anz);
4046 fschmid 341
        int w = Anz->width() + tbWidth + 50;
8562 jghali 342
        resize(qMin(QApplication::desktop()->width()-30,w), 500);
3165 fschmid 343
        if (!PrefsManager::instance()->appPrefs.PrPr_Mode)
344
        {
10947 jghali 345
                if (HaveTiffSep)
346
                        Table->setEnabled(false);
347
                else
3261 fschmid 348
                {
349
                        EnableCMYK_C->setEnabled(false);
350
                        EnableCMYK_M->setEnabled(false);
351
                        EnableCMYK_Y->setEnabled(false);
352
                        EnableCMYK_K->setEnabled(false);
353
                }
3165 fschmid 354
        }
11124 fschmid 355
        PGSel->GotoPg(doc->currentPage()->pageNr());
3172 subik 356
        // tooltips
10397 cbradney 357
        AntiAlias->setToolTip( "<qt>" + tr( "Provides a more pleasant view of Type 1 fonts, TrueType Fonts, OpenType Fonts, EPS, PDF and vector graphics in the preview, at the expense of a slight slowdown in previewing" ) + "</qt>" );
358
        AliasTr->setToolTip( "<qt>" + tr( "Shows transparency and transparent items in your document. Requires Ghostscript 7.07 or later" ) + "</qt>");
359
        EnableCMYK->setToolTip( "<qt>" + tr( "Gives a print preview using simulations of generic CMYK inks, instead of RGB colors" ) + "</qt>");
360
        EnableGCR->setToolTip( "<qt>" + tr( "A way of switching off some of the gray shades which are composed of cyan, yellow and magenta and using black instead. UCR most affects parts of images which are neutral and/or dark tones which are close to the gray. Use of this may improve printing some images and some experimentation and testing is need on a case by case basis. UCR reduces the possibility of over saturation with CMY inks." ) + "</qt>" );
361
        scaleBox->setToolTip( "<qt>" + tr("Resize the scale of the page.") + "</qt>");
362
        spotColors->setToolTip("<qt>" + tr( "Enables Spot Colors to be converted to composite colors. Unless you are planning to print spot colors at a commercial printer, this is probably best left enabled." ) + "</qt>");
10435 cbradney 363
        UseICC->setToolTip("<qt>" + tr( "Allows you to embed color profiles in the print stream when color management is enabled" ) + "</qt>");
6690 fschmid 364
 
3165 fschmid 365
        //signals and slots
6690 fschmid 366
        connect(AntiAlias, SIGNAL(clicked()), this, SLOT(redisplay()));
367
        connect(AliasTr, SIGNAL(clicked()), this, SLOT(redisplay()));
3165 fschmid 368
        connect(EnableCMYK, SIGNAL(clicked()), this, SLOT(ToggleCMYK()));
6690 fschmid 369
        connect(EnableGCR, SIGNAL(clicked()), this, SLOT(redisplay()));
370
        connect(MirrorHor, SIGNAL(clicked()), this, SLOT(redisplay()));
371
        connect(MirrorVert, SIGNAL(clicked()), this, SLOT(redisplay()));
372
        connect(ClipMarg, SIGNAL(clicked()), this, SLOT(redisplay()));
373
        connect(spotColors, SIGNAL(clicked()), this, SLOT(redisplay()));
374
        connect(useGray, SIGNAL(clicked()), this, SLOT(redisplay()));
375
        connect(UseICC, SIGNAL(clicked()), this, SLOT(redisplay()));
10947 jghali 376
        if (!HaveTiffSep)
3261 fschmid 377
        {
378
                connect(EnableCMYK_C, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
379
                connect(EnableCMYK_M, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
380
                connect(EnableCMYK_Y, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
381
                connect(EnableCMYK_K, SIGNAL(clicked()), this, SLOT(ToggleCMYK_Colour()));
10397 cbradney 382
                EnableCMYK_C->setToolTip( tr( "Enable/disable the C (Cyan) ink plate" ) );
383
                EnableCMYK_M->setToolTip( tr( "Enable/disable the M (Magenta) ink plate" ) );
384
                EnableCMYK_Y->setToolTip( tr( "Enable/disable the Y (Yellow) ink plate" ) );
385
                EnableCMYK_K->setToolTip( tr( "Enable/disable the K (Black) ink plate" ) );
3261 fschmid 386
        }
3165 fschmid 387
        connect(PGSel, SIGNAL(GotoPage(int)), this, SLOT(ToSeite(int)));
3488 avox 388
        connect(closeButton, SIGNAL(clicked()), this, SLOT(close()));
3168 fschmid 389
        connect(printButton, SIGNAL(clicked()), this, SIGNAL(doPrint()));
3173 fschmid 390
        connect(scaleBox, SIGNAL(activated(int)), this, SLOT(scaleBox_valueChanged(int)));
3165 fschmid 391
}
392
 
6690 fschmid 393
void PPreview::setValues()
394
{
7104 fschmid 395
        if ((printDinUse) || (!doc->Print_Options.firstUse))
396
        {
397
                EnableGCR->setChecked( postscriptPreview ? doc->Print_Options.doGCR : false);
398
                EnableGCR->setEnabled( postscriptPreview );
399
                MirrorHor->setChecked(doc->Print_Options.mirrorH);
400
                MirrorVert->setChecked(doc->Print_Options.mirrorV);
401
                ClipMarg->setChecked(doc->Print_Options.doClip);
402
                spotColors->setChecked(!doc->Print_Options.useSpotColors);
403
                useGray->setChecked(!doc->Print_Options.useColor);
404
                if (doc->HasCMS)
405
                {
406
                        UseICC->setChecked( postscriptPreview ? doc->Print_Options.useICC : false);
407
                        UseICC->setEnabled( postscriptPreview );
408
                }
409
        }
6690 fschmid 410
        else
411
        {
7104 fschmid 412
                PrefsContext* prefs = PrefsManager::instance()->prefsFile->getContext("print_options");
413
                EnableGCR->setChecked( postscriptPreview ? prefs->getBool("DoGCR", false) : false);
414
                EnableGCR->setEnabled( postscriptPreview );
415
                MirrorHor->setChecked(prefs->getBool("MirrorH", false));
416
                MirrorVert->setChecked(prefs->getBool("MirrorV", false));
417
                ClipMarg->setChecked(prefs->getBool("Clip", false));
418
                spotColors->setChecked(!prefs->getBool("doSpot", true));
419
                if (prefs->getInt("PrintColor", 0) == 1)
420
                        useGray->setChecked(true);
421
                else
422
                        useGray->setChecked(false);
423
                if (doc->HasCMS)
424
                {
425
                        UseICC->setChecked( postscriptPreview ? prefs->getBool("ICCinUse", false) : false);
426
                        UseICC->setEnabled( postscriptPreview );
427
                }
6690 fschmid 428
        }
429
}
430
 
3165 fschmid 431
void PPreview::ToSeite(int num)
432
{
433
        int n = num-1;
434
        if (n == APage)
435
                return;
3173 fschmid 436
        Anz->setPixmap(CreatePreview(n, qRound(72 * scaleFactor)));
11124 fschmid 437
        Anz->resize(Anz->pixmap()->size());
3165 fschmid 438
}
439
 
6690 fschmid 440
void PPreview::redisplay()
3165 fschmid 441
{
3173 fschmid 442
        Anz->setPixmap(CreatePreview(APage, qRound(72 * scaleFactor)));
11124 fschmid 443
        Anz->resize(Anz->pixmap()->size());
3165 fschmid 444
}
445
 
446
void PPreview::ToggleCMYK()
447
{
448
        bool c = EnableCMYK->isChecked() ? true : false;
10947 jghali 449
        if (HaveTiffSep)
13153 fschmid 450
        {
10947 jghali 451
                Table->setEnabled(c);
13153 fschmid 452
                EnableInkCover->setEnabled(c);
453
                CoverThresholdValue->setEnabled(c);
454
        }
10947 jghali 455
        else
3261 fschmid 456
        {
457
                EnableCMYK_C->setEnabled(c);
458
                EnableCMYK_M->setEnabled(c);
459
                EnableCMYK_Y->setEnabled(c);
460
                EnableCMYK_K->setEnabled(c);
461
        }
10947 jghali 462
 
3173 fschmid 463
        Anz->setPixmap(CreatePreview(APage, qRound(72 * scaleFactor)));
11124 fschmid 464
        Anz->resize(Anz->pixmap()->size());
3165 fschmid 465
}
466
 
467
void PPreview::ToggleCMYK_Colour()
468
{
13153 fschmid 469
        if (HaveTiffSep)
470
        {
471
                if ((EnableCMYK->isChecked()) && (EnableInkCover->isChecked()))
472
                        CoverThresholdValue->setEnabled(true);
473
                else
474
                        CoverThresholdValue->setEnabled(false);
475
        }
3165 fschmid 476
        if (EnableCMYK->isChecked())
3173 fschmid 477
                Anz->setPixmap(CreatePreview(APage, qRound(72 * scaleFactor)));
11124 fschmid 478
        Anz->resize(Anz->pixmap()->size());
3165 fschmid 479
}
480
 
13157 fschmid 481
void PPreview::doSpotTable(int row)
482
{
483
        if (HaveTiffSep)
484
        {
485
                QMap<QString, QCheckBox*> ::Iterator sepit;
486
                for (sepit = flagsVisible.begin(); sepit != flagsVisible.end(); ++sepit)
487
                {
488
                        sepit.value()->setChecked(false);
489
                }
490
                ((QCheckBox*)(Table->cellWidget(row, 0)))->setChecked(true);
491
                if (EnableCMYK->isChecked())
492
                        Anz->setPixmap(CreatePreview(APage, qRound(72 * scaleFactor)));
493
                Anz->resize(Anz->pixmap()->size());
494
        }
495
}
496
 
497
void PPreview::toggleAllfromHeader()
498
{
499
        if (HaveTiffSep)
500
        {
501
                QMap<QString, QCheckBox*> ::Iterator sepit;
502
                for (sepit = flagsVisible.begin(); sepit != flagsVisible.end(); ++sepit)
503
                {
504
                        sepit.value()->setChecked(true);
505
                }
506
                if (EnableCMYK->isChecked())
507
                        Anz->setPixmap(CreatePreview(APage, qRound(72 * scaleFactor)));
508
                Anz->resize(Anz->pixmap()->size());
509
        }
510
}
511
 
3172 subik 512
void PPreview::scaleBox_valueChanged(int value)
513
{
3173 fschmid 514
        switch (value)
515
        {
516
                case 0:
517
                        scaleFactor = 0.5;
518
                        break;
519
                case 1:
520
                        scaleFactor = 1.0;
521
                        break;
522
                case 2:
523
                        scaleFactor = 1.5;
524
                        break;
525
                case 3:
526
                        scaleFactor = 2.0;
527
                        break;
6024 fschmid 528
                case 4:
529
                        scaleFactor = Anzeige->viewport()->width() / doc->Pages->at(APage)->width();
530
                        break;
531
                case 5:
532
                        scaleFactor = Anzeige->viewport()->height() / doc->Pages->at(APage)->height();
533
                        break;
534
                case 6:
8562 jghali 535
                        scaleFactor = qMin(Anzeige->viewport()->height() / doc->Pages->at(APage)->height(), Anzeige->viewport()->width() / doc->Pages->at(APage)->width());
6024 fschmid 536
                        break;
3173 fschmid 537
                default:
538
                        scaleFactor = 1.0;
539
                        break;
540
        }
541
        Anz->setPixmap(CreatePreview(APage, qRound(72 * scaleFactor)));
11124 fschmid 542
        Anz->resize(Anz->pixmap()->size());
3172 subik 543
}
544
 
3165 fschmid 545
int PPreview::RenderPreview(int Seite, int Res)
546
{
4194 fschmid 547
        int ret = -1;
3165 fschmid 548
        QString cmd1, cmd2, cmd3;
5387 avox 549
        QMap<QString,QMap<uint, FPointArray> > ReallyUsed;
4361 cbradney 550
#if defined _WIN32
551
        if ( !postscriptPreview )
552
        {
553
                QImage image;
554
                Page* page;
10967 jghali 555
                ScPrintEngine_GDI winPrint;
4361 cbradney 556
                PrintOptions options;
557
                page = doc->Pages->at( Seite );
558
                options.copies = 1;
559
                options.doGCR = false;
10947 jghali 560
                //options.mirrorH = options.mirrorV = false;
561
                options.mirrorH = MirrorHor->isChecked();
562
                options.mirrorV = MirrorVert->isChecked();
4361 cbradney 563
                options.outputSeparations = false;
564
                options.pageNumbers.push_back( Seite );
10947 jghali 565
                options.prnEngine = WindowsGDI;
4361 cbradney 566
                options.separationName = "All";
567
                options.toFile = false;
10947 jghali 568
                options.useColor = !useGray->isChecked();
4361 cbradney 569
                options.useICC = false;
570
                options.useSpotColors = false;
571
                bool done = winPrint.gdiPrintPreview(doc, page, &image, options, Res / 72.0);
572
                if ( done )
6043 jghali 573
                        image.save( ScPaths::getTempFileDir() + "/sc.png", "PNG" );
4361 cbradney 574
                return (done ? 0 : 1);
575
        }
576
#endif
3165 fschmid 577
        // Recreate Postscript-File only when the actual Page has changed
12342 jghali 578
        if ((Seite != APage)  || (EnableGCR->isChecked() != GMode)  || (useGray->isChecked() != fGray)
579
                || (MirrorHor->isChecked() != mHor) || (MirrorVert->isChecked() != mVer) || (ClipMarg->isChecked() != fClip)
580
                || (UseICC->isChecked() != fICC)    || (spotColors->isChecked() != fSpot))
3165 fschmid 581
        {
582
                ReallyUsed.clear();
5387 avox 583
                doc->getUsedFonts(ReallyUsed);
6954 fschmid 584
                bool useIC = UseICC->isChecked();
585
                if (!doc->HasCMS)
586
                        useIC = false;
587
                PrintOptions options;
588
                options.pageNumbers.push_back(Seite+1);
589
                options.outputSeparations = false;
590
                options.separationName = tr("All");
591
                options.allSeparations = QStringList();
592
                options.useColor = !useGray->isChecked();
593
                options.mirrorH = MirrorHor->isChecked();
594
                options.mirrorV = MirrorVert->isChecked();
595
                options.useICC = useIC;
596
                options.doGCR = EnableGCR->isChecked();
597
                options.setDevParam = false;
598
                options.doClip = ClipMarg->isChecked();
599
                options.cropMarks = false;
600
                options.bleedMarks = false;
601
                options.registrationMarks = false;
602
                options.colorMarks = false;
603
                options.markOffset = 0.0;
7225 cbradney 604
                options.bleeds.Top = 0.0;
605
                options.bleeds.Left = 0.0;
606
                options.bleeds.Right = 0.0;
607
                options.bleeds.Bottom = 0.0;
6954 fschmid 608
                PSLib *dd = new PSLib(options, true, prefsManager->appPrefs.AvailFonts, ReallyUsed, doc->PageColors, false, !spotColors->isChecked());
3165 fschmid 609
                if (dd != NULL)
610
                {
6043 jghali 611
                        dd->PS_set_file( ScPaths::getTempFileDir() + "/tmp.ps");
11060 jghali 612
                        ret = dd->CreatePS(doc, options);
3165 fschmid 613
                        delete dd;
11060 jghali 614
                        if (ret != 0) return 1;
3165 fschmid 615
                }
616
                else
617
                        return ret;
618
        }
4194 fschmid 619
        QStringList args;
3165 fschmid 620
        QString tmp, tmp2, tmp3;
3724 cbradney 621
        double b = doc->Pages->at(Seite)->width() * Res / 72.0;
622
        double h = doc->Pages->at(Seite)->height() * Res / 72.0;
15013 jghali 623
        if (doc->Pages->at(Seite)->PageOri == 1)
624
                std::swap(b, h);
625
 
4194 fschmid 626
        args.append( "-q" );
627
        args.append( "-dNOPAUSE" );
628
        args.append( "-dPARANOIDSAFER" );
629
        args.append( QString("-r%1").arg(tmp.setNum(qRound(Res))) );
630
        args.append( QString("-g%1x%2").arg(tmp2.setNum(qRound(b))).arg(tmp3.setNum(qRound(h))) );
3165 fschmid 631
        if (EnableCMYK->isChecked())
3169 fschmid 632
        {
10947 jghali 633
                if (HaveTiffSep)
4194 fschmid 634
                        args.append( "-sDEVICE=tiffsep" );
3169 fschmid 635
                else
4194 fschmid 636
                {
637
                        args.append( "-sDEVICE=bitcmyk" );
638
                        args.append( "-dGrayValues=256" );
639
                }
3169 fschmid 640
        }
3165 fschmid 641
        else
642
        {
10830 fschmid 643
                if ((!AliasTr->isChecked()) || (!HavePngAlpha))
4194 fschmid 644
                        args.append( "-sDEVICE=png16m" );
3165 fschmid 645
                else
4194 fschmid 646
                        args.append( "-sDEVICE=pngalpha" );
3165 fschmid 647
        }
6008 jghali 648
        if (AntiAlias->isChecked())
649
        {
4194 fschmid 650
                args.append( "-dTextAlphaBits=4" );
651
                args.append( "-dGraphicsAlphaBits=4" );
6008 jghali 652
        }
3165 fschmid 653
        // Add any extra font paths being used by Scribus to gs's font search path
654
        PrefsContext *pc = prefsManager->prefsFile->getContext("Fonts");
655
        PrefsTable *extraFonts = pc->getTable("ExtraFontDirs");
4194 fschmid 656
        const char sep = ScPaths::envPathSeparator;
3165 fschmid 657
        if (extraFonts->getRowCount() >= 1)
16576 craig 658
                cmd1 = QString("-sFONTPATH=%1").arg(QDir::toNativeSeparators(extraFonts->get(0,0)));
3165 fschmid 659
        for (int i = 1; i < extraFonts->getRowCount(); ++i)
16576 craig 660
                cmd1 += QString("%1%2").arg(sep).arg(QDir::toNativeSeparators(extraFonts->get(i,0)));
4194 fschmid 661
        if( !cmd1.isEmpty() )
662
                args.append( cmd1 );
3165 fschmid 663
        // then add any final args and call gs
10947 jghali 664
        if ((EnableCMYK->isChecked()) && HaveTiffSep)
16576 craig 665
                args.append( QString("-sOutputFile=%1").arg(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sc.tif")) );
3169 fschmid 666
        else
16576 craig 667
                args.append( QString("-sOutputFile=%1").arg(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sc.png")) );
668
        args.append( QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/tmp.ps") );
4194 fschmid 669
        args.append( "-c" );
670
        args.append( "showpage" );
671
        args.append( "-c" );
672
        args.append( "quit" );
10006 cbradney 673
        ret = System(getShortPathName(prefsManager->ghostscriptExecutable()), args);
3165 fschmid 674
        return ret;
675
}
676
 
3261 fschmid 677
int PPreview::RenderPreviewSep(int Seite, int Res)
678
{
4194 fschmid 679
        int ret = -1;
680
        QString cmd;
681
        QStringList args, args1, args2, args3;
5387 avox 682
        QMap<QString, QMap<uint, FPointArray> > ReallyUsed;
3261 fschmid 683
        // Recreate Postscript-File only when the actual Page has changed
12342 jghali 684
        if ((Seite != APage)  || (EnableGCR->isChecked() != GMode) || (useGray->isChecked() != fGray)
685
                || (MirrorHor->isChecked() != mHor) || (MirrorVert->isChecked() != mVer) || (ClipMarg->isChecked() != fClip)
686
                || (UseICC->isChecked() != fICC) || (spotColors->isChecked() != fSpot))
3261 fschmid 687
        {
688
                ReallyUsed.clear();
5387 avox 689
                doc->getUsedFonts(ReallyUsed);
6954 fschmid 690
                bool useIC = UseICC->isChecked();
691
                if (!doc->HasCMS)
692
                        useIC = false;
693
                PrintOptions options;
694
                options.pageNumbers.push_back(Seite+1);
695
                options.outputSeparations = false;
696
                options.separationName = tr("All");
697
                options.allSeparations = QStringList();
698
                options.useColor = !useGray->isChecked();
699
                options.mirrorH = MirrorHor->isChecked();
700
                options.mirrorV = MirrorVert->isChecked();
701
                options.useICC = useIC;
702
                options.doGCR = EnableGCR->isChecked();
703
                options.setDevParam = false;
704
                options.doClip = ClipMarg->isChecked();
705
                options.cropMarks = false;
706
                options.bleedMarks = false;
707
                options.registrationMarks = false;
708
                options.colorMarks = false;
709
                options.markOffset = 0.0;
7225 cbradney 710
                options.bleeds.Top = 0.0;
711
                options.bleeds.Left = 0.0;
712
                options.bleeds.Right = 0.0;
713
                options.bleeds.Bottom = 0.0;
6954 fschmid 714
                PSLib *dd = new PSLib(options, true, prefsManager->appPrefs.AvailFonts, ReallyUsed, doc->PageColors, false, !spotColors->isChecked());
3261 fschmid 715
                if (dd != NULL)
716
                {
6043 jghali 717
                        dd->PS_set_file(ScPaths::getTempFileDir()+"/tmp.ps");
11060 jghali 718
                        ret = dd->CreatePS(doc, options);
3261 fschmid 719
                        delete dd;
11060 jghali 720
                        if (ret != 0) return 1;
3261 fschmid 721
                }
722
                else
723
                        return ret;
724
        }
725
        QString tmp, tmp2, tmp3;
3724 cbradney 726
        double b = doc->Pages->at(Seite)->width() * Res / 72.0;
727
        double h = doc->Pages->at(Seite)->height() * Res / 72.0;
15013 jghali 728
        if (doc->Pages->at(Seite)->PageOri == 1)
729
                std::swap(b, h);
4194 fschmid 730
 
731
        args1.append( "-q" );
732
        args1.append( "-dNOPAUSE" );
733
        args1.append( "-dPARANOIDSAFER" );
734
        args1.append( QString("-r%1").arg(tmp.setNum(qRound(Res))) );
735
        args1.append( QString("-g%1x%2").arg(tmp2.setNum(qRound(b))).arg(tmp3.setNum(qRound(h))) );
6008 jghali 736
        if (AntiAlias->isChecked())
737
        {
4194 fschmid 738
                args1.append("-dTextAlphaBits=4");
739
                args1.append("-dGraphicsAlphaBits=4");
6008 jghali 740
        }
3261 fschmid 741
        // Add any extra font paths being used by Scribus to gs's font search path
742
        PrefsContext *pc = prefsManager->prefsFile->getContext("Fonts");
743
        PrefsTable *extraFonts = pc->getTable("ExtraFontDirs");
4194 fschmid 744
        const char sep = ScPaths::envPathSeparator;
3261 fschmid 745
        if (extraFonts->getRowCount() >= 1)
16576 craig 746
                cmd = QString("-sFONTPATH=%1").arg(QDir::toNativeSeparators(extraFonts->get(0,0)));
3261 fschmid 747
        for (int i = 1; i < extraFonts->getRowCount(); ++i)
16576 craig 748
                cmd += QString("%1%2").arg(sep).arg(QDir::toNativeSeparators(extraFonts->get(i,0)));
4194 fschmid 749
        if( !cmd.isEmpty() )
750
                args1.append( cmd );
16576 craig 751
        args1.append( QString("-sOutputFile=%1").arg(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sc.tif")) );
4194 fschmid 752
 
16576 craig 753
        args2.append( QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/tmp.ps") );
4194 fschmid 754
        args2.append("-c");
755
        args2.append("quit");
756
 
3261 fschmid 757
        ColorList usedSpots;
758
        doc->getUsedColors(usedSpots, true);
759
        QStringList spots = usedSpots.keys();
4194 fschmid 760
        args3.append( "-sDEVICE=tiffsep" );
761
 
15512 fschmid 762
//      args3.append( "-c" );
4194 fschmid 763
        cmd = "<< /SeparationColorNames ";
3261 fschmid 764
        QString allSeps ="[ /Cyan /Magenta /Yellow /Black ";
8567 jghali 765
        for (int sp = 0; sp < spots.count(); ++sp)
3261 fschmid 766
        {
767
                allSeps += "("+spots[sp]+") ";
768
        }
769
        allSeps += "]";
4194 fschmid 770
        cmd += allSeps + " /SeparationOrder [ /Cyan /Magenta /Yellow /Black] >> setpagedevice";
16576 craig 771
        QFile fx(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sep.ps"));
15512 fschmid 772
        if (fx.open(QIODevice::WriteOnly))
773
        {
774
                QTextStream tsx(&fx);
775
                tsx << cmd;
776
                fx.close();
777
        }
778
        args3.append("-f");
16576 craig 779
        args3.append(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sep.ps"));
15512 fschmid 780
//      args3.append(cmd);
4194 fschmid 781
 
15512 fschmid 782
//      args3.append("-f");
10006 cbradney 783
        QString gsExe(getShortPathName(prefsManager->ghostscriptExecutable()));
784
        ret = System(gsExe, args1 + args3 + args2, ScPaths::getTempFileDir()+"/sc.tif.txt" );
4194 fschmid 785
 
16576 craig 786
        QFile sepInfo(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sc.tif.txt"));
3261 fschmid 787
        sepsToFileNum.clear();
8501 cbradney 788
        if (sepInfo.open(QIODevice::ReadOnly))
3261 fschmid 789
        {
790
                QString Sname;
9988 fschmid 791
                QTextStream tsC(&sepInfo);
3261 fschmid 792
                int counter = 0;
793
                while (!tsC.atEnd())
794
                {
795
                        Sname = tsC.readLine();
10394 cbradney 796
                        QString tt = Sname.remove("%%SeparationName:").trimmed();
10649 fschmid 797
                        if (!tt.isEmpty())
798
                        {
799
                                sepsToFileNum.insert(tt, counter);
800
                                counter++;
801
                        }
3261 fschmid 802
                }
803
        }
804
        sepInfo.close();
805
        QString currSeps = "";
806
        uint spc = 0;
8567 jghali 807
        for (int sp = 0; sp < spots.count(); ++sp)
3261 fschmid 808
        {
809
                currSeps += "("+spots[sp]+") ";
810
                spc++;
811
                if (sp > 6)
812
                {
4194 fschmid 813
                        args3.clear();
814
                        args3.append("-sDEVICE=tiffsep");
16576 craig 815
                        QFile fx(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sep.ps"));
15512 fschmid 816
                        if (fx.open(QIODevice::WriteOnly))
817
                        {
818
                                QTextStream tsx(&fx);
819
                                tsx << QString("<< /SeparationColorNames "+allSeps+" /SeparationOrder [ "+currSeps+" ] >> setpagedevice");
820
                                fx.close();
821
                        }
4194 fschmid 822
                        args3.append("-f");
16576 craig 823
                        args3.append(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sep.ps"));
10006 cbradney 824
                        ret = System(gsExe, args1 + args3 + args2);
3261 fschmid 825
                        currSeps = "";
826
                        spc = 0;
827
                }
828
        }
829
        if (spc != 0)
830
        {
4194 fschmid 831
                args3.clear();
832
                args3.append("-sDEVICE=tiffsep");
16576 craig 833
                QFile fx(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sep.ps"));
15512 fschmid 834
                if (fx.open(QIODevice::WriteOnly))
835
                {
836
                        QTextStream tsx(&fx);
837
                        tsx << QString("<< /SeparationColorNames "+allSeps+" /SeparationOrder [ "+currSeps+" ] >> setpagedevice");
838
                        fx.close();
839
                }
4194 fschmid 840
                args3.append("-f");
16576 craig 841
                args3.append(QDir::toNativeSeparators(ScPaths::getTempFileDir()+"/sep.ps"));
10006 cbradney 842
                ret = System(gsExe, args1 + args3 + args2);
3261 fschmid 843
        }
844
        return ret;
845
}
846
 
5593 avox 847
// this should move to scimage.cpp!
848
void PPreview::blendImages(QImage &target, ScImage &scsource, ScColor col)
3261 fschmid 849
{
5593 avox 850
        QImage source = scsource.qImage(); // FIXME: this will not work once qImage always returns ARGB!
851
 
3300 avox 852
        //FIXME: if source and target have different sizesomething went wrong.
853
        // eg. loadPicture() failed and returned a 1x1 image
9622 jghali 854
        CMYKColor cmykValues;
8562 jghali 855
        int h = qMin(target.height(),source.height());
856
        int w = qMin(target.width(),source.width());
3261 fschmid 857
        int cyan, c, m, yc, k, cc, mm, yy, kk;
9622 jghali 858
        ScColorEngine::getCMYKValues(col, doc, cmykValues);
859
        cmykValues.getValues(c, m, yc, k);
3261 fschmid 860
        for (int y=0; y < h; ++y )
861
        {
862
                QRgb *p = (QRgb *)target.scanLine( y );
863
                QRgb *pq = (QRgb *)source.scanLine( y );
864
                for (int x=0; x < w; ++x )
865
                {
866
                        cyan = 255 - qRed(*pq);
867
                        if (cyan != 0)
868
                        {
8562 jghali 869
                                (c == 0) ? cc = qRed(*p) : cc = qMin(c * cyan / 255 + qRed(*p), 255);
870
                                (m == 0) ? mm = qGreen(*p) : mm = qMin(m * cyan / 255 + qGreen(*p), 255);
871
                                (yc == 0) ? yy = qBlue(*p) : yy = qMin(yc * cyan / 255 + qBlue(*p), 255);
872
                                (k == 0) ? kk = qAlpha(*p) : kk = qMin(k * cyan / 255 + qAlpha(*p), 255);
3261 fschmid 873
                                *p = qRgba(cc, mm, yy, kk);
874
                        }
875
                        p++;
876
                        pq++;
877
                }
878
        }
879
}
880
 
13153 fschmid 881
void PPreview::blendImagesSumUp(QImage &target, ScImage &scsource)
882
{
883
        QImage source = scsource.qImage(); // FIXME: this will not work once qImage always returns ARGB!
884
        //FIXME: if source and target have different sizesomething went wrong.
885
        // eg. loadPicture() failed and returned a 1x1 image
886
        int h = qMin(target.height(),source.height());
887
        int w = qMin(target.width(),source.width());
888
        int cyan;
889
        for (int y=0; y < h; ++y )
890
        {
891
                uint *p = (QRgb *)target.scanLine( y );
892
                QRgb *pq = (QRgb *)source.scanLine( y );
893
                for (int x=0; x < w; ++x )
894
                {
895
                        cyan = 255 - qRed(*pq);
896
                        if (cyan != 0)
897
                        {
898
                                *p += cyan;
899
                        }
900
                        p++;
901
                        pq++;
902
                }
903
        }
904
}
905
 
3165 fschmid 906
QPixmap PPreview::CreatePreview(int Seite, int Res)
907
{
908
        int ret = -1;
909
        QPixmap Bild;
3724 cbradney 910
        double b = doc->Pages->at(Seite)->width() * Res / 72.0;
911
        double h = doc->Pages->at(Seite)->height() * Res / 72.0;
9380 fschmid 912
        qApp->changeOverrideCursor(QCursor(Qt::WaitCursor));
10553 fschmid 913
        if ((Seite != APage) || (EnableCMYK->isChecked() != CMode) || (SMode != scaleBox->currentIndex())
12521 fschmid 914
                || (AntiAlias->isChecked() != GsAl) || (((AliasTr->isChecked() != Trans) || (EnableGCR->isChecked() != GMode))
12342 jghali 915
                        && (!EnableCMYK->isChecked()))
6690 fschmid 916
                         || (useGray->isChecked() != fGray) || (MirrorHor->isChecked() != mHor) || (MirrorVert->isChecked() != mVer)
917
                         || (ClipMarg->isChecked() != fClip) || (UseICC->isChecked() != fICC) || (spotColors->isChecked() != fSpot))
3165 fschmid 918
        {
10947 jghali 919
                if (!EnableCMYK->isChecked() || (!HaveTiffSep))
3165 fschmid 920
                {
3261 fschmid 921
                        ret = RenderPreview(Seite, Res);
11124 fschmid 922
                        if (ret > 0)
3261 fschmid 923
                        {
6394 cbradney 924
                                imageLoadError(Bild, Seite);
3261 fschmid 925
                                return Bild;
926
                        }
3165 fschmid 927
                }
928
        }
929
        QImage image;
930
        if (EnableCMYK->isChecked())
931
        {
932
                int cyan, magenta, yellow, black, alpha;
933
                uint *p;
6392 fschmid 934
                bool loaderror;
10947 jghali 935
                if (HaveTiffSep)
3165 fschmid 936
                {
10553 fschmid 937
                        if ((Seite != APage) || (EnableCMYK->isChecked() != CMode) || (SMode != scaleBox->currentIndex())
6745 fschmid 938
                 || (AntiAlias->isChecked() != GsAl) || (AliasTr->isChecked() != Trans) || (EnableGCR->isChecked() != GMode)
12342 jghali 939
                 || (useGray->isChecked() != fGray)  || (MirrorHor->isChecked() != mHor)|| (MirrorVert->isChecked() != mVer)
940
                 || (ClipMarg->isChecked() != fClip) || (UseICC->isChecked() != fICC) || (spotColors->isChecked() != fSpot))
3261 fschmid 941
                        {
942
                                ret = RenderPreviewSep(Seite, Res);
11124 fschmid 943
                                if (ret > 0)
6392 fschmid 944
                                {
6394 cbradney 945
                                        imageLoadError(Bild, Seite);
6392 fschmid 946
                                        return Bild;
947
                                }
3261 fschmid 948
                        }
3169 fschmid 949
                        ScImage im;
950
                        bool mode;
3261 fschmid 951
                        int w = qRound(b);
952
                        int h2 = qRound(h);
15013 jghali 953
                        if (doc->Pages->at(Seite)->PageOri == 1)
954
                                std::swap(w, h2);
10553 fschmid 955
                        image = QImage(w, h2, QImage::Format_ARGB32);
4618 fschmid 956
                        QRgb clean = qRgba(0, 0, 0, 0);
957
                        for( int yi=0; yi < h2; ++yi )
958
                        {
959
                                QRgb *q = (QRgb*)(image.scanLine( yi ));
960
                                for(int xi=0; xi < w; ++xi )
961
                                {
962
                                        *q = clean;
963
                                        q++;
964
                                }
965
                        }
15706 jghali 966
                        CMSettings cms(doc, "", Intent_Perceptual);
3268 fschmid 967
                        if (flagsVisible["Cyan"]->isChecked())
3165 fschmid 968
                        {
15512 fschmid 969
                                if ((GsMinor < 54) && (GsMajor < 9))
12141 avox 970
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.tif.Cyan.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
17860 jghali 971
                                else if ((GsMajor < 9) || ((GsMajor == 9) && (GsMinor <= 5)))
972
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.Cyan.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
5542 fschmid 973
                                else
17860 jghali 974
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc(Cyan).tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
6392 fschmid 975
                                if (!loaderror)
976
                                {
6394 cbradney 977
                                        imageLoadError(Bild, Seite);
6392 fschmid 978
                                        return Bild;
979
                                }
13153 fschmid 980
                                if (EnableInkCover->isChecked())
981
                                        blendImagesSumUp(image, im);
982
                                else
983
                                        blendImages(image, im, ScColor(255, 0, 0, 0));
3165 fschmid 984
                        }
3268 fschmid 985
                        if (flagsVisible["Magenta"]->isChecked())
986
                        {
15512 fschmid 987
                                if ((GsMinor < 54) && (GsMajor < 9))
12141 avox 988
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.tif.Magenta.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
17860 jghali 989
                                else if ((GsMajor < 9) || ((GsMajor == 9) && (GsMinor <= 5)))
990
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.Magenta.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
5542 fschmid 991
                                else
17860 jghali 992
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc(Magenta).tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
6392 fschmid 993
                                if (!loaderror)
994
                                {
6394 cbradney 995
                                        imageLoadError(Bild, Seite);
6392 fschmid 996
                                        return Bild;
997
                                }
13153 fschmid 998
                                if (EnableInkCover->isChecked())
999
                                        blendImagesSumUp(image, im);
1000
                                else
1001
                                        blendImages(image, im, ScColor(0, 255, 0, 0));
3268 fschmid 1002
                        }
1003
                        if (flagsVisible["Yellow"]->isChecked())
1004
                        {
15512 fschmid 1005
                                if ((GsMinor < 54) && (GsMajor < 9))
12141 avox 1006
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.tif.Yellow.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
17860 jghali 1007
                                else if ((GsMajor < 9) || ((GsMajor == 9) && (GsMinor <= 5)))
1008
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.Yellow.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
5542 fschmid 1009
                                else
17860 jghali 1010
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc(Yellow).tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
6392 fschmid 1011
                                if (!loaderror)
1012
                                {
6394 cbradney 1013
                                        imageLoadError(Bild, Seite);
6392 fschmid 1014
                                        return Bild;
1015
                                }
13153 fschmid 1016
                                if (EnableInkCover->isChecked())
1017
                                        blendImagesSumUp(image, im);
1018
                                else
1019
                                        blendImages(image, im, ScColor(0, 0, 255, 0));
3268 fschmid 1020
                        }
10649 fschmid 1021
                        if (!sepsToFileNum.isEmpty())
3261 fschmid 1022
                        {
10649 fschmid 1023
                                QMap<QString, int>::Iterator sepit;
1024
                                for (sepit = sepsToFileNum.begin(); sepit != sepsToFileNum.end(); ++sepit)
3261 fschmid 1025
                                {
14325 jghali 1026
                                        const QCheckBox* checkBox = flagsVisible.value(sepit.key(), NULL);
1027
                                        if (checkBox && checkBox->isChecked())
6392 fschmid 1028
                                        {
10649 fschmid 1029
                                                QString fnam;
15512 fschmid 1030
                                                if ((GsMinor < 54) && (GsMajor < 9))
10649 fschmid 1031
                                                        fnam = QString(ScPaths::getTempFileDir()+"/sc.tif.s%1.tif").arg(sepit.value());
17860 jghali 1032
                                                else if ((GsMajor < 9) || ((GsMajor == 9) && (GsMinor <= 5)))
1033
                                                        fnam = QString(ScPaths::getTempFileDir()+"/sc.s%1.tif").arg(sepit.value());
10649 fschmid 1034
                                                else
17860 jghali 1035
                                                        fnam = QString(ScPaths::getTempFileDir()+"/sc(%1).tif").arg(sepit.key());
12141 avox 1036
                                                if (!im.LoadPicture(fnam, 1, cms, false, false, ScImage::RGBData, 72, &mode))
10649 fschmid 1037
                                                {
1038
                                                        imageLoadError(Bild, Seite);
1039
                                                        return Bild;
1040
                                                }
13153 fschmid 1041
                                                if (EnableInkCover->isChecked())
1042
                                                        blendImagesSumUp(image, im);
1043
                                                else
1044
                                                        blendImages(image, im, doc->PageColors[sepit.key()]);
6392 fschmid 1045
                                        }
3261 fschmid 1046
                                }
1047
                        }
1048
                        if (flagsVisible["Black"]->isChecked())
1049
                        {
15706 jghali 1050
                                CMSettings cms(doc, "", Intent_Perceptual);
15512 fschmid 1051
                                if ((GsMinor < 54) && (GsMajor < 9))
12141 avox 1052
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.tif.Black.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
17860 jghali 1053
                                else if ((GsMajor < 9) || ((GsMajor == 9) && (GsMinor <= 5)))
1054
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc.Black.tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
5542 fschmid 1055
                                else
17860 jghali 1056
                                        loaderror = im.LoadPicture(ScPaths::getTempFileDir()+"/sc(Black).tif", 1, cms, false, false, ScImage::RGBData, 72, &mode);
6392 fschmid 1057
                                if (!loaderror)
1058
                                {
6394 cbradney 1059
                                        imageLoadError(Bild, Seite);
6392 fschmid 1060
                                        return Bild;
1061
                                }
13153 fschmid 1062
                                if (EnableInkCover->isChecked())
1063
                                        blendImagesSumUp(image, im);
1064
                                else
1065
                                        blendImages(image, im, ScColor(0, 0, 0, 255));
3261 fschmid 1066
                        }
13153 fschmid 1067
                        if (EnableInkCover->isChecked())
3261 fschmid 1068
                        {
13153 fschmid 1069
                                uint limitVal = (CoverThresholdValue->value() * 255) / 100;
6702 fschmid 1070
                                for( int yi=0; yi < h2; ++yi )
3261 fschmid 1071
                                {
13153 fschmid 1072
                                        QRgb *q = (QRgb*)(image.scanLine( yi ));
1073
                                        for(int xi=0; xi < w; ++xi )
3268 fschmid 1074
                                        {
13153 fschmid 1075
                                                uint greyVal = *q;
1076
                                                if (greyVal != 0)
6702 fschmid 1077
                                                {
13173 fschmid 1078
                                                        if (limitVal == 0)
1079
                                                        {
1080
                                                                QColor tmpC;
1081
                                                                tmpC.setHsv((greyVal * 359) / inkMax, 255, 255);
1082
                                                                *q = tmpC.rgba();
1083
                                                        }
6702 fschmid 1084
                                                        else
13173 fschmid 1085
                                                        {
1086
                                                                int col = qMin(255 - static_cast<int>(((greyVal * 128) / inkMax) * 2), 255);
1087
                                                                if ((*q > 0) && (*q < limitVal))
1088
                                                                        *q = qRgba(col, col, col, 255);
1089
                                                                else
1090
                                                                        *q = qRgba(col, 0, 0, 255);
1091
                                                        }
6702 fschmid 1092
                                                }
1093
                                                else
13173 fschmid 1094
                                                {
1095
                                                        if (!AliasTr->isChecked())
1096
                                                                *q = qRgba(255, 255, 255, 255);
1097
                                                }
13153 fschmid 1098
                                                q++;
3268 fschmid 1099
                                        }
3261 fschmid 1100
                                }
1101
                        }
6702 fschmid 1102
                        else
1103
                        {
13153 fschmid 1104
                                if (doc->HasCMS)
6702 fschmid 1105
                                {
13153 fschmid 1106
                                        QRgb alphaFF = qRgba(0,0,0,255);
1107
                                        QRgb alphaOO = qRgba(255,255,255,0);
15706 jghali 1108
                                        ScColorTransform transCMYK = ScColorMgmtEngine::createTransform(doc->DocPrinterProf, Format_YMCK_8, doc->DocOutputProf, Format_BGRA_8, Intent_Relative_Colorimetric, Ctf_LowResPrecalc);
13153 fschmid 1109
                                        for( int yi=0; yi < h2; ++yi )
6702 fschmid 1110
                                        {
15706 jghali 1111
                                                uchar* ptr = image.scanLine( yi );
1112
                                                transCMYK.apply(ptr, ptr, image.width());
13153 fschmid 1113
                                                QRgb *q = (QRgb *) ptr;
1114
                                                for (int xi = 0; xi < image.width(); xi++, q++)
6702 fschmid 1115
                                                {
13153 fschmid 1116
                                                        if (AliasTr->isChecked())
1117
                                                        {
1118
                                                                cyan = qRed(*q);
1119
                                                                magenta = qGreen(*q);
1120
                                                                yellow = qBlue(*q);
1121
                                                                if      ((cyan == 255) && (magenta == 255) && (yellow == 255))
1122
                                                                        *q = alphaOO;
1123
                                                                else
1124
                                                                        *q |= alphaFF;
1125
                                                        }
1126
                                                        else
1127
                                                                *q |= alphaFF;
6702 fschmid 1128
                                                }
1129
                                        }
1130
                                }
13153 fschmid 1131
                                else
1132
                                {
1133
                                        for( int yi=0; yi < h2; ++yi )
1134
                                        {
1135
                                                QRgb *q = (QRgb*)(image.scanLine( yi ));
1136
                                                for(int xi=0; xi < w; ++xi )
1137
                                                {
1138
                                                        cyan = qRed(*q);
1139
                                                        magenta = qGreen(*q);
1140
                                                        yellow = qBlue(*q);
1141
                                                        black = qAlpha(*q);
1142
                                                        if ((cyan != 0) || (magenta != 0) || (yellow != 0 ) || (black != 0))
1143
                                                                *q = qRgba(255-qMin(255, cyan+black), 255-qMin(255,magenta+black), 255-qMin(255,yellow+black), 255);
1144
                                                        else
1145
                                                        {
1146
                                                                if (!AliasTr->isChecked())
1147
                                                                        *q = qRgba(255, 255, 255, 255);
1148
                                                        }
1149
                                                        q++;
1150
                                                }
1151
                                        }
1152
                                }
6702 fschmid 1153
                        }
3165 fschmid 1154
                }
3169 fschmid 1155
                else
1156
                {
3173 fschmid 1157
                        int w = qRound(b);
1158
                        int w2 = 4*w;
1159
                        int h2 = qRound(h);
10553 fschmid 1160
                        image = QImage(w, h2, QImage::Format_ARGB32);
1161
                        QByteArray imgc(w2, ' ');
6043 jghali 1162
                        QFile f(ScPaths::getTempFileDir()+"/sc.png");
8501 cbradney 1163
                        if (f.open(QIODevice::ReadOnly))
3169 fschmid 1164
                        {
6702 fschmid 1165
                                if (doc->HasCMS)
3169 fschmid 1166
                                {
6702 fschmid 1167
                                        QRgb alphaFF = qRgba(0,0,0,255);
1168
                                        QRgb alphaOO = qRgba(255,255,255,0);
15706 jghali 1169
                                        ScColorTransform transCMYK = ScColorMgmtEngine::createTransform(doc->DocPrinterProf, Format_YMCK_8, doc->DocOutputProf, Format_BGRA_8, Intent_Relative_Colorimetric, Ctf_LowResPrecalc);
6702 fschmid 1170
                                        for (int y=0; y < h2; ++y )
3169 fschmid 1171
                                        {
15706 jghali 1172
                                                uchar* ptr = image.scanLine( y );
10553 fschmid 1173
                                                f.read(imgc.data(), w2);
6702 fschmid 1174
                                                p = (uint *)image.scanLine( y );
1175
                                                for (int x=0; x < w2; x += 4 )
1176
                                                {
1177
                                                        cyan = uchar(imgc[x]);
1178
                                                        magenta = uchar(imgc[x + 1]);
1179
                                                        yellow = uchar(imgc[x + 2]);
1180
                                                        black = uchar(imgc[x + 3]);
1181
                                                        if (!EnableCMYK_C->isChecked())
1182
                                                                cyan = 0;
1183
                                                        if (!EnableCMYK_M->isChecked())
1184
                                                                magenta = 0;
1185
                                                        if (!EnableCMYK_Y->isChecked())
1186
                                                                yellow = 0;
1187
                                                        if (!EnableCMYK_K->isChecked())
1188
                                                                black = 0;
1189
                                                        *p = qRgba(cyan, magenta, yellow, black);
1190
                                                        p++;
1191
                                                }
15706 jghali 1192
                                                transCMYK.apply(ptr, ptr, image.width());
6702 fschmid 1193
                                                QRgb *q = (QRgb *) ptr;
1194
                                                for (int xi = 0; xi < image.width(); xi++, q++)
1195
                                                {
1196
                                                        if (AliasTr->isChecked())
1197
                                                        {
1198
                                                                cyan = qRed(*q);
1199
                                                                magenta = qGreen(*q);
1200
                                                                yellow = qBlue(*q);
1201
                                                                if      ((cyan == 255) && (magenta == 255) && (yellow == 255))
1202
                                                                        *q = alphaOO;
1203
                                                                else
1204
                                                                        *q |= alphaFF;
1205
                                                        }
1206
                                                        else
1207
                                                                *q |= alphaFF;
1208
                                                }
3169 fschmid 1209
                                        }
1210
                                }
6702 fschmid 1211
                                else
1212
                                {
1213
                                        for (int y=0; y < h2; ++y )
1214
                                        {
1215
                                                p = (uint *)image.scanLine( y );
10553 fschmid 1216
                                                f.read(imgc.data(), w2);
6702 fschmid 1217
                                                for (int x=0; x < w2; x += 4 )
1218
                                                {
1219
                                                        cyan = uchar(imgc[x]);
1220
                                                        magenta = uchar(imgc[x + 1]);
1221
                                                        yellow = uchar(imgc[x + 2]);
1222
                                                        black = uchar(imgc[x + 3]);
1223
                                                        if (!EnableCMYK_C->isChecked())
1224
                                                                cyan = 0;
1225
                                                        if (!EnableCMYK_M->isChecked())
1226
                                                                magenta = 0;
1227
                                                        if (!EnableCMYK_Y->isChecked())
1228
                                                                yellow = 0;
1229
                                                        if (!EnableCMYK_K->isChecked())
1230
                                                                black = 0;
1231
                                                        if (AliasTr->isChecked() && ((cyan == 0) && (magenta == 0) && (yellow == 0 ) && (black == 0)))
1232
                                                                alpha = 0;
1233
                                                        else
1234
                                                                alpha = 255;
8562 jghali 1235
                                                        *p = qRgba(255-qMin(255, cyan+black), 255-qMin(255,magenta+black), 255-qMin(255,yellow+black), alpha);
6702 fschmid 1236
                                                        p++;
1237
                                                }
1238
                                        }
1239
                                }
3169 fschmid 1240
                                f.close();
1241
                        }
6392 fschmid 1242
                        else
1243
                        {
6394 cbradney 1244
                                imageLoadError(Bild, Seite);
6392 fschmid 1245
                                return Bild;
1246
                        }
3169 fschmid 1247
                }
3165 fschmid 1248
        }
1249
        else
1250
        {
6392 fschmid 1251
                if (!image.load(ScPaths::getTempFileDir()+"/sc.png"))
1252
                {
6394 cbradney 1253
                        imageLoadError(Bild, Seite);
6392 fschmid 1254
                        return Bild;
1255
                }
10553 fschmid 1256
                image = image.convertToFormat(QImage::Format_ARGB32);
10830 fschmid 1257
                if ((AliasTr->isChecked()) && (HavePngAlpha))
3165 fschmid 1258
                {
1259
                        int wi = image.width();
1260
                        int hi = image.height();
1261
                        for( int yi=0; yi < hi; ++yi )
1262
                        {
1263
                                QRgb *s = (QRgb*)(image.scanLine( yi ));
1264
                                for(int xi=0; xi < wi; ++xi )
1265
                                {
1266
                                        if((*s) == 0xffffffff)
1267
                                                (*s) &= 0x00ffffff;
1268
                                        s++;
1269
                                }
1270
                        }
1271
                }
1272
        }
15013 jghali 1273
        const Page* page = doc->Pages->at(Seite);
1274
        if ((page->PageOri == 1) && (image.width() < image.height()))
1275
                image = image.transformed( QMatrix(0, 1, -1, 0, 0, 0) );
3165 fschmid 1276
        if (AliasTr->isChecked())
1277
        {
1278
                Bild = QPixmap(image.width(), image.height());
1279
                QPainter p;
1280
                QBrush b(QColor(205,205,205), loadIcon("testfill.png"));
1281
                p.begin(&Bild);
1282
                p.fillRect(0, 0, image.width(), image.height(), b);
1283
                p.drawImage(0, 0, image);
1284
                p.end();
1285
        }
1286
        else
10553 fschmid 1287
                Bild = QPixmap::fromImage(image);
9380 fschmid 1288
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
6394 cbradney 1289
        getUserSelection(Seite);
3165 fschmid 1290
        return Bild;
1291
}
1292
 
4361 cbradney 1293
//-------------------------------------------------------------------------------------------------
1294
 
10947 jghali 1295
bool PPreview::usePostscriptPreview(QString printerName, PrintEngine engine)
4361 cbradney 1296
{
1297
#ifdef _WIN32
1298
        if ( printerName == tr("File") )
1299
                return true;
1300
        else if( printerName.isEmpty() )
10967 jghali 1301
                return PrinterUtil::isPostscriptPrinter( ScPrintEngine_GDI::getDefaultPrinter() );
10947 jghali 1302
        else if( engine >= PostScript1 && engine <= PostScript3 )
4506 cbradney 1303
                return PrinterUtil::isPostscriptPrinter( printerName );
10947 jghali 1304
        return false;
4361 cbradney 1305
#else
1306
        return true;
1307
#endif
1308
}
1309
 
1310
//-------------------------------------------------------------------------------------------------
1311
 
6394 cbradney 1312
void PPreview::getUserSelection(int page)
6393 cbradney 1313
{
6394 cbradney 1314
        APage = page;
6393 cbradney 1315
        CMode = EnableCMYK->isChecked();
1316
        GsAl = AntiAlias->isChecked();
1317
        Trans = AliasTr->isChecked();
1318
        GMode = EnableGCR->isChecked();
10553 fschmid 1319
        SMode = scaleBox->currentIndex();
6690 fschmid 1320
        mHor = MirrorHor->isChecked();
1321
        mVer = MirrorVert->isChecked();
1322
        fClip = ClipMarg->isChecked();
1323
        fSpot = spotColors->isChecked();
1324
        fGray = useGray->isChecked();
1325
        fICC = UseICC->isChecked();
6393 cbradney 1326
}
1327
 
6394 cbradney 1328
void PPreview::imageLoadError(QPixmap &Bild, int page)
6393 cbradney 1329
{
10553 fschmid 1330
        Bild = QPixmap(1,1);
9380 fschmid 1331
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
6394 cbradney 1332
        getUserSelection(page);
1333
}
11940 subik 1334
 
1335
void PPreview::resizeEvent(QResizeEvent * event)
1336
{
1337
        QDialog::resizeEvent(event);
1338
        int cx = scaleBox->currentIndex();
1339
        // repaint only for "fit to" options in the combo box
1340
        if (cx > 3)
1341
        {
1342
                // HACK: SMode is reset to insane value to force redraw
1343
                // as the value is checked for change.
1344
                SMode = -1;
1345
                scaleBox_valueChanged(cx);
1346
        }
1347
}