Subversion Repositories Scribus

Rev

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