File indexing completed on 2024-04-21 14:55:34

 /* This file is part of the KDE libraries
    Copyright (C) 1999 Sirtaj Singh Kanq <taj@kde.org>
    Copyright (C) 2007 Matthias Kretz <kretz@kde.org>
    Copyright (C) 2009 Olivier Goffart <ogoffart@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 /*
  * kglobal.cpp -- Implementation of namespace KGlobal.
  * Author:  Sirtaj Singh Kang
  * Generated:   Sat May  1 02:08:43 EST 1999
  */
 
 #undef KDE3_SUPPORT
 
 #include "kglobal.h"
 #include <QThread>
 
 #include <config-kdelibs4support.h>
 
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 
 #include <QList>
 #include <QSet>
 
 #include <k4aboutdata.h>
 #include <kconfig.h>
 #include <klocalizedstring.h>
 #include <kcharsets.h>
 #include "kstandarddirs.h"
 #include <kcomponentdata.h>
 #undef QT_NO_TRANSLATION
 #include <QCoreApplication>
 #define QT_NO_TRANSLATION
 #include <QTextCodec>
 #include <unistd.h> // umask
 
 // ~KConfig needs qrand(). qrand() depends on a Q_GLOBAL_STATIC. With this Q_CONSTRUCTOR_FUNCTION we
 // try to make qrand() live longer than any KConfig object.
 Q_CONSTRUCTOR_FUNCTION(qrand)
 
 typedef QSet<QString> KStringDict;
 mode_t s_umsk;
 
 class KGlobalPrivate
 {
 public:
     inline KGlobalPrivate()
         : dirs(nullptr),
           stringDict(nullptr)
     {
         // the umask is read here before any threads are created to avoid race conditions
         mode_t tmp = 0;
         s_umsk = umask(tmp);
         umask(s_umsk);
     }
 
     inline ~KGlobalPrivate()
     {
         delete dirs;
         dirs = nullptr;
         delete stringDict;
         stringDict = nullptr;
     }
 
     KStandardDirs *dirs;
     KStringDict *stringDict;
 };
 
 K_GLOBAL_STATIC(KGlobalPrivate, globalData)
 
 #define PRIVATE_DATA KGlobalPrivate *d = globalData
 
 KStandardDirs *KGlobal::dirs()
 {
     PRIVATE_DATA;
     if (!d->dirs) {
         d->dirs = new KStandardDirs;
         KSharedConfig::Ptr config = KSharedConfig::openConfig();
         if (d->dirs->addCustomized(config.data())) {
             config->reparseConfiguration();
         }
     }
     return d->dirs;
 }
 
 KSharedConfig::Ptr KGlobal::config()
 {
     return KComponentData::mainComponent().config();
 }
 
 const KComponentData &KGlobal::mainComponent()
 {
     return KComponentData::mainComponent();
 }
 
 bool KGlobal::hasMainComponent()
 {
     return KComponentData::hasMainComponent();
 }
 
 KGlobal::LocaleWrapper KGlobal::locale()
 {
     return KGlobal::LocaleWrapper(KLocale::global());
 }
 
 bool KGlobal::hasLocale()
 {
     return QCoreApplication::instance() != nullptr;
 }
 
 KCharsets *KGlobal::charsets()
 {
     return KCharsets::charsets();
 }
 
 mode_t KGlobal::umask()
 {
     // Don't use PRIVATE_DATA here. This is called by ~KGlobalPrivate -> ~KConfig -> sync -> KSaveFile, so there's no KGlobalPrivate anymore.
     return s_umsk;
 }
 
 KComponentData KGlobal::activeComponent()
 {
     return KComponentData::activeComponent();
 }
 
 void KGlobal::setActiveComponent(const KComponentData &c)
 {
     KComponentData::setActiveComponent(c);
 }
 
 /**
  * Create a static QString
  *
  * To be used inside functions(!) like:
  * static const QString &myString = KGlobal::staticQString("myText");
  */
 const QString &KGlobal::staticQString(const char *str)
 {
     return staticQString(QLatin1String(str));
 }
 
 /**
  * Create a static QString
  *
  * To be used inside functions(!) like:
  * static const QString &myString = KGlobal::staticQString(i18n("My Text"));
  */
 const QString &KGlobal::staticQString(const QString &str)
 {
     PRIVATE_DATA;
     if (!d->stringDict) {
         d->stringDict = new KStringDict;
     }
 
     return *d->stringDict->insert(str);
 }
 
 QString KGlobal::caption()
 {
 #if 0 // Should move to Qt if wanted
     // Caption set from command line ?
     KCmdLineArgs *args = KCmdLineArgs::parsedArgs("kde");
     if (args && args->isSet("caption")) {
         return args->getOption("caption");
     } else
 #endif
     {
         // We have some about data ?
         const KComponentData &cData = KComponentData::mainComponent();
         if (cData.isValid() && cData.aboutData()) {
             return cData.aboutData()->programName();
         } else {
             // Last resort : application name
             return QCoreApplication::instance()->applicationName();
         }
     }
 }
 
 /**
  * This counter indicates when to quit the application.
  * It starts at 0, is incremented by KMainWindow, systray icons, running jobs, etc.
  * and decremented again when those things are destroyed.
  * This mechanism allows dialogs and jobs to outlive the last window closed
  * e.g. a file copy for a file manager, or 'compacting folders on exit' for a mail client,
  * the job progress widget with "keep open" checked, etc.
  */
 static int s_refCount = 0;
 static bool s_allowQuit = false;
 
 void KGlobal::ref()
 {
     ++s_refCount;
     //kDebug() << "KGlobal::ref() : refCount = " << s_refCount;
 }
 
 void KGlobal::deref()
 {
     --s_refCount;
     //kDebug() << "KGlobal::deref() : refCount = " << s_refCount;
     if (s_refCount <= 0 && s_allowQuit) {
         QCoreApplication::instance()->quit();
     }
 }
 
 void KGlobal::setAllowQuit(bool allowQuit)
 {
     s_allowQuit = allowQuit;
 }
 
 #undef PRIVATE_DATA
 
 QObject *KGlobal::findDirectChild_helper(const QObject *parent, const QMetaObject &mo)
 {
     if (!parent) {
         return nullptr;
     }
 
     const QObjectList &children = parent->children();
     for (int i = 0; i < children.size(); ++i) {
         QObject *obj = children.at(i);
         if (mo.cast(obj)) {
             return obj;
         }
     }
     return nullptr;
 
 }