Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
5244 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
*/
7
/***************************************************************************
8
                          pageitem.h  -  description
9
                             -------------------
10
    copyright            : Scribus Team
11
 ***************************************************************************/
12
 
13
/***************************************************************************
14
 *                                                                         *
15
 *   This program is free software; you can redistribute it and/or modify  *
16
 *   it under the terms of the GNU General Public License as published by  *
17
 *   the Free Software Foundation; either version 2 of the License, or     *
18
 *   (at your option) any later version.                                   *
19
 *                                                                         *
20
 ***************************************************************************/
21
 
22
#include "scribuscore.h"
23
#include "scribuscore.moc"
24
 
25
#include "commonstrings.h"
26
#include "filewatcher.h"
27
#include "gsutil.h"
28
#include "pluginmanager.h"
29
#include "prefsmanager.h"
30
#include "scpaths.h"
31
#include "splash.h"
32
#include "scribusapp.h"
33
#include "undomanager.h"
34
 
35
extern ScribusQApp* ScQApp;
36
 
37
#ifdef HAVE_CMS
38
#include "cmserrorhandling.h"
39
cmsHPROFILE CMSoutputProf;
40
cmsHPROFILE CMSprinterProf;
5369 mrdocs 41
cmsHTRANSFORM stdTransRGBMonG;
42
cmsHTRANSFORM stdTransCMYKMonG;
5244 cbradney 43
cmsHTRANSFORM stdProofG;
44
cmsHTRANSFORM stdTransImgG;
45
cmsHTRANSFORM stdProofImgG;
46
cmsHTRANSFORM stdTransCMYKG;
47
cmsHTRANSFORM stdProofCMYKG;
48
cmsHTRANSFORM stdTransRGBG;
49
cmsHTRANSFORM stdProofGCG;
50
cmsHTRANSFORM stdProofCMYKGCG;
51
bool BlackPoint;
52
bool SoftProofing;
53
bool Gamut;
54
bool SCRIBUS_API CMSuse;
5345 mrdocs 55
int IntentColors;
56
int IntentImages;
5244 cbradney 57
#endif
58
bool CMSavail;
59
 
60
 
61
ScribusCore::ScribusCore() : QObject()
62
{
63
        m_ScribusInitialized=false;
64
        m_SplashScreen=0;
65
        m_UseGUI=false;
5257 cbradney 66
        m_PaletteParent=0;
5418 cbradney 67
        m_currScMW=0;
5244 cbradney 68
}
69
 
70
 
71
 
72
ScribusCore::~ScribusCore()
5257 cbradney 73
{
74
        delete m_PaletteParent;
75
}
5244 cbradney 76
 
77
int ScribusCore::init(bool useGUI, bool swapDialogButtonOrder, const QString fileToUse)
78
{
79
        m_UseGUI=useGUI;
80
        m_File=fileToUse;
81
        m_SwapDialogButtonOrder=swapDialogButtonOrder;
82
        return 0;
83
}
84
 
85
int ScribusCore::startGUI(bool showSplash, bool showFontInfo, const QString newGuiLanguage, const QString prefsUserFile)
86
{
5257 cbradney 87
        m_PaletteParent=new QWidget(0);
88
        Q_CHECK_PTR(m_PaletteParent);
5418 cbradney 89
        ScribusMainWindow* scribus = new ScribusMainWindow();
5257 cbradney 90
        Q_CHECK_PTR(scribus);
91
        if (!scribus)
92
                return(EXIT_FAILURE);
5418 cbradney 93
        ScMWList.append(scribus);
94
        m_currScMW=0;
5257 cbradney 95
        ScMW=scribus;
96
        int retVal=initScribusCore(showSplash, showFontInfo, newGuiLanguage, prefsUserFile);
97
        if (retVal == 1)
98
                return(EXIT_FAILURE);
99
        retVal = scribus->initScMW(true);
100
        if (retVal == 1)
101
                return(EXIT_FAILURE);
102
        closeSplash();
103
        m_ScribusInitialized=true;
104
        ScQApp->setMainWidget(scribus);
105
        connect(ScQApp, SIGNAL(lastWindowClosed()), ScQApp, SLOT(quit()));
5244 cbradney 106
 
5257 cbradney 107
        scribus->show();
108
        scribus->ShowSubs();
5244 cbradney 109
 
5257 cbradney 110
        if (!m_File.isEmpty())
111
                scribus->loadDoc(m_File);
112
        else
113
        {
114
                if (PrefsManager::instance()->appPrefs.showStartupDialog)
115
                        scribus->startUpDialog();
5244 cbradney 116
                else
5257 cbradney 117
                        scribus->setFocus();
118
        }
5244 cbradney 119
 
5257 cbradney 120
        // A hook for plug-ins and scripts to trigger on. Some plugins and scripts
121
        // require the app to be fully set up (in particular, the main window to be
122
        // built and shown) before running their setup.
123
        emit appStarted();
124
        return EXIT_SUCCESS;
5244 cbradney 125
}
126
 
127
int ScribusCore::initScribusCore(bool showSplash, bool showFontInfo, const QString newGuiLanguage, const QString prefsUserFile)
128
{
129
        CommonStrings::languageChange();
130
        int retVal=0;
131
//FIXME ExternalApp = 0;
132
        m_GuiLanguage = newGuiLanguage;
133
        initSplash(showSplash);
134
        prefsManager = PrefsManager::instance();
135
        prefsManager->setup();
136
        prefsManager->initDefaults();
137
        prefsManager->initDefaultGUIFont(qApp->font());
138
        prefsManager->initArrowStyles();
139
        undoManager = UndoManager::instance();
140
        fileWatcher = new FileWatcher(this);
141
        pluginManager = new PluginManager();
142
        setSplashStatus( tr("Initializing Plugins") );
143
        pluginManager->initPlugs();
144
        bool haveFonts=false;
145
#ifdef QT_MAC
146
        haveFonts=ScCore->initFonts(true);
147
#else
148
        haveFonts=ScCore->initFonts(showFontInfo);
149
#endif
150
        if (!haveFonts)
151
                return 1;
152
        setSplashStatus( tr("Initializing Keyboard Shortcuts") );
153
        prefsManager->initDefaultActionKeys();
154
        setSplashStatus( tr("Reading Preferences") );
155
        if (prefsUserFile.isNull())
156
                prefsManager->ReadPrefs();
157
        else
158
                prefsManager->ReadPrefs(prefsUserFile);
159
 
160
        m_HaveGS = testGSAvailability();
161
        m_HavePngAlpha = testGSDeviceAvailability("pngalpha");
162
        m_HaveTiffSep = testGSDeviceAvailability("tiffsep");
163
 
164
        ScCore->setSplashStatus( tr("Reading ICC Profiles") );
165
        CMSavail = false;
166
        getCMSProfiles();
167
        initCMS();
168
        /*
169
 
5257 cbradney 170
                buildFontMenu();
5244 cbradney 171
 
172
 
173
                initPalettes();
174
 
175
 
176
                setSplashStatus( tr("Initializing Hyphenator") );
177
                QString preLang = prefsManager->appPrefs.Language;
178
                initHyphenator();
179
                if (Sprachen.contains(preLang))
180
                        prefsManager->appPrefs.Language = preLang;
181
                setSplashStatus( tr("Reading Scrapbook") );
182
                initScrapbook();
183
                setSplashStatus( tr("Setting up Shortcuts") );
184
                SetShortCut();
185
                scrActions["helpTooltips"]->setOn(prefsManager->appPrefs.showToolTips);
186
                ToggleTips();
187
 
188
                connect(fileWatcher, SIGNAL(fileDeleted(QString )), this, SLOT(removeRecent(QString)));
189
                connect(this, SIGNAL(TextIFont(QString)), this, SLOT(AdjustFontMenu(QString)));
190
                connect(this, SIGNAL(TextIFont(QString)), propertiesPalette, SLOT(setFontFace(QString)));
191
                connect(this, SIGNAL(TextISize(int)), this, SLOT(setFSizeMenu(int)));
192
                connect(this, SIGNAL(TextISize(int)), propertiesPalette, SLOT(setSize(int)));
193
                connect(this, SIGNAL(TextUSval(int)), propertiesPalette, SLOT(setExtra(int)));
194
                connect(this, SIGNAL(TextStil(int)), propertiesPalette, SLOT(setStil(int)));
195
                connect(this, SIGNAL(TextScale(int)), propertiesPalette, SLOT(setTScale(int)));
196
                connect(this, SIGNAL(TextScaleV(int)), propertiesPalette, SLOT(setTScaleV(int)));
197
                connect(this, SIGNAL(TextBase(int)), propertiesPalette, SLOT(setTBase(int)));
198
                connect(this, SIGNAL(TextShadow(int, int )), propertiesPalette, SLOT(setShadowOffs(int, int )));
199
                connect(this, SIGNAL(TextOutline(int)), propertiesPalette, SLOT(setOutlineW(int)));
200
                connect(this, SIGNAL(TextUnderline(int, int)), propertiesPalette, SLOT(setUnderline(int, int)));
201
                connect(this, SIGNAL(TextStrike(int, int)), propertiesPalette, SLOT(setStrike(int, int)));
202
                connect(this, SIGNAL(TextFarben(QString, QString, int, int)), propertiesPalette, SLOT(setActFarben(QString, QString, int, int)));
203
        }*/
5257 cbradney 204
 
5244 cbradney 205
        return retVal;
206
}
207
 
208
 
209
void ScribusCore::initSplash(bool showSplash)
210
{
211
        if (showSplash)
212
        {
213
                m_SplashScreen = new SplashScreen();
214
                if (m_SplashScreen != NULL && m_SplashScreen->isShown())
215
                        setSplashStatus(QObject::tr("Initializing..."));
216
        }
217
        else
218
                m_SplashScreen = NULL;
219
}
220
 
221
void ScribusCore::setSplashStatus(const QString& newText)
222
{
223
        if (m_SplashScreen != NULL)
224
        {
225
                m_SplashScreen->setStatus( newText );
226
                qApp->processEvents();
227
        }
228
}
229
 
230
void ScribusCore::showSplash(bool shown)
231
{
232
        if (m_SplashScreen!=NULL && shown!=m_SplashScreen->isShown())
233
                m_SplashScreen->setShown(shown);
234
}
235
 
236
bool ScribusCore::splashShowing() const
237
{
238
        if (m_SplashScreen != NULL)
239
                return m_SplashScreen->isShown();
240
        return false;
241
}
242
 
243
void ScribusCore::closeSplash()
244
{
245
        if (m_SplashScreen!=NULL)
246
        {
247
                m_SplashScreen->close();
248
                delete m_SplashScreen;
249
                m_SplashScreen = NULL;
250
        }
251
}
252
 
253
bool ScribusCore::usingGUI() const
254
{
255
        return m_UseGUI;
256
}
257
 
258
bool ScribusCore::isMacGUI() const
259
{
260
        // Do it statically for now
261
#if defined(Q_WS_MAC)
262
        return true;
263
#else
264
        return false;
265
#endif
266
}
267
 
268
bool ScribusCore::isWinGUI() const
269
{
270
        // Do it statically for now
271
#if defined(_WIN32)
272
        return true;
273
#else
274
        return false;
275
#endif
276
}
277
 
278
bool ScribusCore::reverseDialogButtons() const
279
{
280
        if (m_SwapDialogButtonOrder)
281
                return true;
282
        //Win32 - dont switch
283
        #if defined(_WIN32)
284
                return false;
285
        //Mac Aqua - switch
286
        #elif defined(Q_WS_MAC)
287
                return true;
288
        #else
289
        //Gnome - switch
290
        QString gnomesession= ::getenv("GNOME_DESKTOP_SESSION_ID");
291
        if (!gnomesession.isEmpty())
292
                return true;
293
 
294
        //KDE/KDE Aqua - dont switch
295
        //Best guess for now if we are running under KDE
296
        QString kdesession= ::getenv("KDE_FULL_SESSION");
297
        if (!kdesession.isEmpty())
298
                return false;
299
        #endif
300
        return false;
301
}
302
 
303
//Returns false when there are no fonts
304
bool ScribusCore::initFonts(bool showFontInfo)
305
{
306
        setSplashStatus( tr("Searching for Fonts") );
307
        bool haveFonts=prefsManager->GetAllFonts(showFontInfo);
308
        if (!haveFonts)
309
        {
310
                closeSplash();
311
                QString mess = tr("There are no fonts found on your system.");
312
                mess += "\n" + tr("Exiting now.");
313
                QMessageBox::critical(0, tr("Fatal Error"), mess, 1, 0, 0);
314
        }
315
        else
316
                setSplashStatus( tr("Font System Initialized") );
317
        return haveFonts;
318
}
319
 
320
 
321
void ScribusCore::getCMSProfiles()
322
{
323
        QString profDir;
324
        QStringList profDirs;
325
        MonitorProfiles.clear();
326
        PrinterProfiles.clear();
327
        InputProfiles.clear();
328
        InputProfilesCMYK.clear();
329
        QString pfad = ScPaths::instance().libDir();
330
        pfad += "profiles/";
331
        profDirs = ScPaths::getSystemProfilesDirs();
332
        profDirs.prepend( prefsManager->appPrefs.ProfileDir );
333
        profDirs.prepend( pfad );
334
        for(unsigned int i = 0; i < profDirs.count(); i++)
335
        {
336
                profDir = profDirs[i];
337
                if(!profDir.isEmpty())
338
                {
339
                        if(profDir.right(1) != "/")
340
                                profDir += "/";
341
                        getCMSProfilesDir(profDir);
342
                }
343
        }
344
        if ((!PrinterProfiles.isEmpty()) && (!InputProfiles.isEmpty()) && (!MonitorProfiles.isEmpty()))
345
                CMSavail = true;
346
        else
347
                CMSavail = false;
348
}
349
 
350
void ScribusCore::getCMSProfilesDir(QString pfad)
351
{
352
#ifdef HAVE_CMS
353
        QDir d(pfad, "*", QDir::Name, QDir::Files | QDir::Readable | QDir::Dirs | QDir::NoSymLinks);
354
        if ((d.exists()) && (d.count() != 0))
355
        {
356
                QString nam = "";
357
                const char *Descriptor;
358
                cmsHPROFILE hIn = NULL;
359
 
360
                for (uint dc = 0; dc < d.count(); ++dc)
361
                {
362
                        QFileInfo fi(pfad + "/" + d[dc]);
363
                        if (fi.isDir() && d[dc][0] != '.')
364
                        {
365
                                getCMSProfilesDir(fi.filePath()+"/");
366
                                continue;
367
                        }
368
 
369
#ifndef QT_MAC
370
                        QString ext = fi.extension(false).lower();
371
                        if ((ext != "icm") && (ext != "icc"))
372
                                continue;
373
#endif
374
 
375
                        QFile f(fi.filePath());
376
                        QByteArray bb(40);
377
                        if (!f.open(IO_ReadOnly)) {
378
                                qDebug("%s", QString("couldn't open %1 as ICC").arg(fi.filePath()).ascii());
379
                                continue;
380
                        }
381
                        int len = f.readBlock(bb.data(), 40);
382
                        f.close();
383
                        if (len == 40 && bb[36] == 'a' && bb[37] == 'c' && bb[38] == 's' && bb[39] == 'p')
384
                        {
385
                                const QCString profilePath( QString(pfad + d[dc]).local8Bit() );
386
                                if (setjmp(cmsJumpBuffer))
387
                                {
388
                                        // Reset to the default handler otherwise may enter a loop
389
                                        // if an error occur in cmsCloseProfile()
390
                                        cmsSetErrorHandler(NULL);
391
                                        if (hIn)
392
                                        {
393
                                                cmsCloseProfile(hIn);
394
                                                hIn = NULL;
395
                                        }
396
                                        continue;
397
                                }
398
                                cmsSetErrorHandler(&cmsErrorHandler);
399
                                hIn = cmsOpenProfileFromFile(profilePath.data(), "r");
400
                                if (hIn == NULL)
401
                                        continue;
402
                                Descriptor = cmsTakeProductDesc(hIn);
403
                                nam = QString(Descriptor);
404
                                switch (static_cast<int>(cmsGetDeviceClass(hIn)))
405
                                {
406
                                case icSigInputClass:
407
                                case icSigColorSpaceClass:
408
                                        if (static_cast<int>(cmsGetColorSpace(hIn)) == icSigRgbData)
409
                                                InputProfiles[nam] = pfad + d[dc];
410
                                        if (static_cast<int>(cmsGetColorSpace(hIn)) == icSigCmykData)
411
                                                InputProfilesCMYK[nam] = pfad + d[dc];
412
                                        break;
413
                                case icSigDisplayClass:
414
                                        if (static_cast<int>(cmsGetColorSpace(hIn)) == icSigRgbData)
415
                                        {
416
                                                MonitorProfiles[nam] = pfad + d[dc];
417
                                                InputProfiles[nam] = pfad + d[dc];
418
                                        }
419
                                        if (static_cast<int>(cmsGetColorSpace(hIn)) == icSigCmykData)
420
                                                InputProfilesCMYK[nam] = pfad + d[dc];
421
                                        break;
422
                                case icSigOutputClass:
423
                                        PrinterProfiles[nam] = pfad + d[dc];
424
                                        if (static_cast<int>(cmsGetColorSpace(hIn)) == icSigCmykData)
425
                                        {
426
                                                PDFXProfiles[nam] = pfad + d[dc];
427
                                                InputProfilesCMYK[nam] = pfad + d[dc];
428
                                        }
429
                                        break;
430
                                }
431
                                cmsCloseProfile(hIn);
432
                                hIn = NULL;
433
                        }
434
                }
435
                cmsSetErrorHandler(NULL);
436
        }
437
#endif
438
}
439
 
440
void ScribusCore::initCMS()
441
{
442
        if (CMSavail)
443
        {
444
                ProfilesL::Iterator ip;
445
                if ((prefsManager->appPrefs.DCMSset.DefaultImageRGBProfile.isEmpty()) || (!InputProfiles.contains(prefsManager->appPrefs.DCMSset.DefaultImageRGBProfile)))
446
                {
447
                        ip = InputProfiles.begin();
448
                        prefsManager->appPrefs.DCMSset.DefaultImageRGBProfile = ip.key();
449
                }
450
                if ((prefsManager->appPrefs.DCMSset.DefaultImageCMYKProfile.isEmpty()) || (!InputProfilesCMYK.contains(prefsManager->appPrefs.DCMSset.DefaultImageCMYKProfile)))
451
                {
452
                        ip = InputProfilesCMYK.begin();
453
                        prefsManager->appPrefs.DCMSset.DefaultImageCMYKProfile = ip.key();
454
                }
5345 mrdocs 455
                if ((prefsManager->appPrefs.DCMSset.DefaultSolidColorRGBProfile.isEmpty()) || (!InputProfiles.contains(prefsManager->appPrefs.DCMSset.DefaultSolidColorRGBProfile)))
5244 cbradney 456
                {
457
                        ip = InputProfiles.begin();
5345 mrdocs 458
                        prefsManager->appPrefs.DCMSset.DefaultSolidColorRGBProfile = ip.key();
5244 cbradney 459
                }
5345 mrdocs 460
                if ((prefsManager->appPrefs.DCMSset.DefaultSolidColorCMYKProfile.isEmpty()) || (!InputProfilesCMYK.contains(prefsManager->appPrefs.DCMSset.DefaultSolidColorCMYKProfile)))
461
                {
462
                        ip = InputProfilesCMYK.begin();
463
                        prefsManager->appPrefs.DCMSset.DefaultSolidColorCMYKProfile = ip.key();
464
                }
5244 cbradney 465
                if ((prefsManager->appPrefs.DCMSset.DefaultMonitorProfile.isEmpty()) || (!MonitorProfiles.contains(prefsManager->appPrefs.DCMSset.DefaultMonitorProfile)))
466
                {
467
                        ip = MonitorProfiles.begin();
468
                        prefsManager->appPrefs.DCMSset.DefaultMonitorProfile = ip.key();
469
                }
470
                if ((prefsManager->appPrefs.DCMSset.DefaultPrinterProfile.isEmpty()) || (!PrinterProfiles.contains(prefsManager->appPrefs.DCMSset.DefaultPrinterProfile)))
471
                {
472
                        ip = PrinterProfiles.begin();
473
                        prefsManager->appPrefs.DCMSset.DefaultPrinterProfile = ip.key();
474
                }
475
#ifdef HAVE_CMS
476
                SoftProofing = prefsManager->appPrefs.DCMSset.SoftProofOn;
477
                CMSuse = false;
5345 mrdocs 478
                IntentColors = prefsManager->appPrefs.DCMSset.DefaultIntentColors;
479
                IntentImages = prefsManager->appPrefs.DCMSset.DefaultIntentImages;
5244 cbradney 480
#endif
481
        }
482
}
5418 cbradney 483
 
484
ScribusMainWindow * ScribusCore::primaryMainWindow( )
485
{
486
        if (ScMWList.count()==0 || m_currScMW>ScMWList.count())
487
                return 0;
488
        ScribusMainWindow* mw=ScMWList.at(m_currScMW);
489
        if (!mw)
490
                return 0;
491
        return mw;
492
}