/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qcoreapplication.h"

#include "qcoreapplication_p.h"

#include "qabstracteventdispatcher.h"

#include "qcoreevent.h"

#include "qeventloop.h"

#include "qcorecmdlineargs_p.h"

#include <qdatastream.h>

#include <qdebug.h>

#include <qdir.h>

#include <qfile.h>

#include <qfileinfo.h>

#include <qhash.h>

#include <private/qprocess_p.h>

#include <qtextcodec.h>

#include <qthread.h>

#include <qthreadpool.h>

#include <qthreadstorage.h>

#include <private/qthread_p.h>

#include <qelapsedtimer.h>

#include <qlibraryinfo.h>

#include <qvarlengtharray.h>

#include <private/qfactoryloader_p.h>

#include <private/qfunctions_p.h>

#include <private/qlocale_p.h>

#ifdef Q_OS_SYMBIAN

#  include <exception>

#  include <f32file.h>

#  include <e32ldr.h>

#  include "qeventdispatcher_symbian_p.h"

#  include "private/qcore_symbian_p.h"

#elif defined(Q_OS_UNIX)

#  if !defined(QT_NO_GLIB)

#    include "qeventdispatcher_glib_p.h"

#  endif

#  include "qeventdispatcher_unix_p.h"

#endif

#ifdef Q_OS_WIN

#  include "qeventdispatcher_win_p.h"

#endif

#ifdef Q_OS_MAC

#  include "qcore_mac_p.h"

#endif

#include <stdlib.h>

#ifdef Q_OS_UNIX

#  include <locale.h>

#endif

#ifdef Q_OS_VXWORKS

#  include <taskLib.h>

#endif

QT_BEGIN_NAMESPACE

class QMutexUnlocker

{

public:

    inline explicit QMutexUnlocker(QMutex *m)

        : mtx(m)

    { }

    inline ~QMutexUnlocker() { unlock(); }

    inline void unlock() { if (mtx) mtx->unlock(); mtx = 0; }

private:

    Q_DISABLE_COPY(QMutexUnlocker)

    QMutex *mtx;

};

#ifdef Q_OS_SYMBIAN

typedef TDriveNumber (*SystemDriveFunc)(RFs&);

static SystemDriveFunc PtrGetSystemDrive=0;

#endif

#if defined(Q_WS_WIN) || defined(Q_WS_MAC)

extern QString qAppFileName();

#endif

#if !defined(Q_OS_WIN)

#ifdef Q_OS_MAC

QString QCoreApplicationPrivate::macMenuBarName()

{

    QString bundleName;

    CFTypeRef string = CFBundleGetValueForInfoDictionaryKey(CFBundleGetMainBundle(), CFSTR("CFBundleName"));

    if (string)

        bundleName = QCFString::toQString(static_cast<CFStringRef>(string));

    return bundleName;

}

#endif

QString QCoreApplicationPrivate::appName() const

{

    static QString applName;

#ifdef Q_OS_MAC

    applName = macMenuBarName();

#endif

    if (applName.isEmpty() && argv[0]) {

        char *p = strrchr(argv[0], '/');

        applName = QString::fromLocal8Bit(p ? p + 1 : argv[0]);

    }

    return applName;

}

#endif

bool QCoreApplicationPrivate::checkInstance(const char *function)

{

    bool b = (QCoreApplication::self != 0);

    if (!b)

        qWarning("QApplication::%s: Please instantiate the QApplication object first", function);

    return b;

}

// Support for introspection

QSignalSpyCallbackSet Q_CORE_EXPORT qt_signal_spy_callback_set = { 0, 0, 0, 0 };

void qt_register_signal_spy_callbacks(const QSignalSpyCallbackSet &callback_set)

{

    qt_signal_spy_callback_set = callback_set;

}

extern "C" void Q_CORE_EXPORT qt_startup_hook()

{

}

typedef QList<QtCleanUpFunction> QVFuncList;

Q_GLOBAL_STATIC(QVFuncList, postRList)

void qAddPostRoutine(QtCleanUpFunction p)

{

    QVFuncList *list = postRList();

    if (!list)

        return;

    list->prepend(p);

}

void qRemovePostRoutine(QtCleanUpFunction p)

{

    QVFuncList *list = postRList();

    if (!list)

        return;

    list->removeAll(p);

}

void Q_CORE_EXPORT qt_call_post_routines()

{

    QVFuncList *list = 0;

    QT_TRY {

        list = postRList();

    } QT_CATCH(const std::bad_alloc &) {

        // ignore - if we can't allocate a post routine list,

        // there's a high probability that there's no post

        // routine to be executed :)

    }

    if (!list)

        return;

    while (!list->isEmpty())

        (list->takeFirst())();

}

// app starting up if false

bool QCoreApplicationPrivate::is_app_running = false;

 // app closing down if true

bool QCoreApplicationPrivate::is_app_closing = false;

// initialized in qcoreapplication and in qtextstream autotest when setlocale is called.

Q_CORE_EXPORT bool qt_locale_initialized = false;

Q_CORE_EXPORT uint qGlobalPostedEventsCount()

{

    QThreadData *currentThreadData = QThreadData::current();

    return currentThreadData->postEventList.size() - currentThreadData->postEventList.startOffset;

}

void qt_set_current_thread_to_main_thread()

{

    QCoreApplicationPrivate::theMainThread = QThread::currentThread();

}

QCoreApplication *QCoreApplication::self = 0;

QAbstractEventDispatcher *QCoreApplicationPrivate::eventDispatcher = 0;

uint QCoreApplicationPrivate::attribs;

#ifdef Q_OS_UNIX

Qt::HANDLE qt_application_thread_id = 0;

#endif

struct QCoreApplicationData {

    QCoreApplicationData() {

#ifndef QT_NO_LIBRARY

        app_libpaths = 0;

#endif

    }

    ~QCoreApplicationData() {

#ifndef QT_NO_LIBRARY

        delete app_libpaths;

#endif

        // cleanup the QAdoptedThread created for the main() thread

       if (QCoreApplicationPrivate::theMainThread) {

           QThreadData *data = QThreadData::get2(QCoreApplicationPrivate::theMainThread);

           QCoreApplicationPrivate::theMainThread = 0;

           data->deref(); // deletes the data and the adopted thread

       }

    }

    QString orgName, orgDomain, application;

    QString applicationVersion;

#ifndef QT_NO_LIBRARY

    QStringList *app_libpaths;

#endif

};

Q_GLOBAL_STATIC(QCoreApplicationData, coreappdata)

QCoreApplicationPrivate::QCoreApplicationPrivate(int &aargc, char **aargv)

    : QObjectPrivate(), argc(aargc), argv(aargv), application_type(0), eventFilter(0),

      in_exec(false), aboutToQuitEmitted(false)

{

    static const char *const empty = "";

    if (argc == 0 || argv == 0) {

        argc = 0;

        argv = (char **)∅ // ouch! careful with QCoreApplication::argv()!

    }

    QCoreApplicationPrivate::is_app_closing = false;

#ifdef Q_OS_UNIX

    qt_application_thread_id = QThread::currentThreadId();

#endif

    // note: this call to QThread::currentThread() may end up setting theMainThread!

    if (QThread::currentThread() != theMainThread)

        qWarning("WARNING: QApplication was not created in the main() thread.");

}

QCoreApplicationPrivate::~QCoreApplicationPrivate()

{

    if (threadData) {

#ifndef QT_NO_THREAD

        void *data = &threadData->tls;

        QThreadStorageData::finish((void **)data);

#endif

        // need to clear the state of the mainData, just in case a new QCoreApplication comes along.

        QMutexLocker locker(&threadData->postEventList.mutex);

        for (int i = 0; i < threadData->postEventList.size(); ++i) {

            const QPostEvent &pe = threadData->postEventList.at(i);

            if (pe.event) {

                --pe.receiver->d_func()->postedEvents;

                pe.event->posted = false;

                delete pe.event;

            }

        }

        threadData->postEventList.clear();

        threadData->postEventList.recursion = 0;

        threadData->quitNow = false;

    }

}

void QCoreApplicationPrivate::createEventDispatcher()

{

    Q_Q(QCoreApplication);

#if defined(Q_OS_SYMBIAN)

    eventDispatcher = new QEventDispatcherSymbian(q);

#elif defined(Q_OS_UNIX)

#  if !defined(QT_NO_GLIB)

    if (qgetenv("QT_NO_GLIB").isEmpty() && QEventDispatcherGlib::versionSupported())

        eventDispatcher = new QEventDispatcherGlib(q);

    else

#  endif

        eventDispatcher = new QEventDispatcherUNIX(q);

#elif defined(Q_OS_WIN)

    eventDispatcher = new QEventDispatcherWin32(q);

#else

#  error "QEventDispatcher not yet ported to this platform"

#endif

}

QThread *QCoreApplicationPrivate::theMainThread = 0;

QThread *QCoreApplicationPrivate::mainThread()

{

    Q_ASSERT(theMainThread != 0);

    return theMainThread;

}

#if !defined (QT_NO_DEBUG) || defined (QT_MAC_FRAMEWORK_BUILD)

void QCoreApplicationPrivate::checkReceiverThread(QObject *receiver)

{

    QThread *currentThread = QThread::currentThread();

    QThread *thr = receiver->thread();

    Q_ASSERT_X(currentThread == thr || !thr,

               "QCoreApplication::sendEvent",

               QString::fromLatin1("Cannot send events to objects owned by a different thread. "

                                   "Current thread %1. Receiver '%2' (of type '%3') was created in thread %4")

               .arg(QString::number((quintptr) currentThread, 16))

               .arg(receiver->objectName())

               .arg(QLatin1String(receiver->metaObject()->className()))

               .arg(QString::number((quintptr) thr, 16))

               .toLocal8Bit().data());

    Q_UNUSED(currentThread);

    Q_UNUSED(thr);

}

#elif defined(Q_OS_SYMBIAN) && defined (QT_NO_DEBUG)

// no implementation in release builds, but keep the symbol present

void QCoreApplicationPrivate::checkReceiverThread(QObject * /* receiver */)

{

}

#endif

void QCoreApplicationPrivate::appendApplicationPathToLibraryPaths()

{

#if !defined(QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)

    QStringList *app_libpaths = coreappdata()->app_libpaths;

    Q_ASSERT(app_libpaths);

# if defined(Q_OS_SYMBIAN)

    QString app_location( QCoreApplication::applicationDirPath() );

    // File existence check for application's private dir requires additional '\' or

    // platform security will not allow it.

    if (app_location !=  QLibraryInfo::location(QLibraryInfo::PluginsPath) && QFile::exists(app_location + QLatin1Char('\\')) && !app_libpaths->contains(app_location))

# else

    QString app_location( QCoreApplication::applicationFilePath() );

    app_location.truncate(app_location.lastIndexOf(QLatin1Char('/')));

    app_location = QDir(app_location).canonicalPath();

    if (QFile::exists(app_location) && !app_libpaths->contains(app_location))

# endif

        app_libpaths->append(app_location);

#endif

}

QString qAppName()

{

    if (!QCoreApplicationPrivate::checkInstance("qAppName"))

        return QString();

    return QCoreApplication::instance()->d_func()->appName();

}

/*!

    \class QCoreApplication

    \brief The QCoreApplication class provides an event loop for console Qt

    applications.

    This class is used by non-GUI applications to provide their event

    loop. For non-GUI application that uses Qt, there should be exactly

    one QCoreApplication object. For GUI applications, see

    QApplication.

    QCoreApplication contains the main event loop, where all events

    from the operating system (e.g., timer and network events) and

    other sources are processed and dispatched. It also handles the

    application's initialization and finalization, as well as

    system-wide and application-wide settings.

    \section1 The Event Loop and Event Handling

    The event loop is started with a call to exec(). Long running

    operations can call processEvents() to keep the application

    responsive.

    Some Qt classes, such as QString, can be used without a

    QCoreApplication object. However, in general, we recommend that

    you create a QCoreApplication or a QApplication object in your \c

    main() function as early as possible. exit() will not return

    until the event loop exits; e.g., when quit() is called.

    Several static convenience functions are also provided. The

    QCoreApplication object is available from instance(). Events can

    be sent or posted using sendEvent(), postEvent(), and

    sendPostedEvents(). Pending events can be removed with

    removePostedEvents() or flushed with flush().

    The class provides a quit() slot and an aboutToQuit() signal.

    \section1 Application and Library Paths

    An application has an applicationDirPath() and an

    applicationFilePath(). Library paths (see QLibrary) can be retrieved

    with libraryPaths() and manipulated by setLibraryPaths(), addLibraryPath(),

    and removeLibraryPath().

    \section1 Internationalization and Translations

    Translation files can be added or removed

    using installTranslator() and removeTranslator(). Application

    strings can be translated using translate(). The QObject::tr()

    and QObject::trUtf8() functions are implemented in terms of

    translate().

    \section1 Accessing Command Line Arguments

    The command line arguments which are passed to QCoreApplication's

    constructor should be accessed using the arguments() function.

    Note that some arguments supplied by the user may have been

    processed and removed by QCoreApplication.

    In cases where command line arguments need to be obtained using the

    argv() function, you must convert them from the local string encoding

    using QString::fromLocal8Bit().

    \section1 Locale Settings

    On Unix/Linux Qt is configured to use the system locale settings by

    default. This can cause a conflict when using POSIX functions, for

    instance, when converting between data types such as floats and

    strings, since the notation may differ between locales. To get

    around this problem, call the POSIX function \c{setlocale(LC_NUMERIC,"C")}

    right after initializing QApplication or QCoreApplication to reset

    the locale that is used for number formatting to "C"-locale.

    \sa QApplication, QAbstractEventDispatcher, QEventLoop,

    {Semaphores Example}, {Wait Conditions Example}

*/

/*!

    \fn static QCoreApplication *QCoreApplication::instance()

    Returns a pointer to the application's QCoreApplication (or

    QApplication) instance.

    If no instance has been allocated, \c null is returned.

*/

/*!\internal

 */

QCoreApplication::QCoreApplication(QCoreApplicationPrivate &p)

    : QObject(p, 0)

{

    init();

    // note: it is the subclasses' job to call

    // QCoreApplicationPrivate::eventDispatcher->startingUp();

}

/*!

    Flushes the platform specific event queues.

    If you are doing graphical changes inside a loop that does not

    return to the event loop on asynchronous window systems like X11

    or double buffered window systems like Mac OS X, and you want to

    visualize these changes immediately (e.g. Splash Screens), call

    this function.

    \sa sendPostedEvents()

*/

void QCoreApplication::flush()

{

    if (self && self->d_func()->eventDispatcher)

        self->d_func()->eventDispatcher->flush();

}

/*!

    Constructs a Qt kernel application. Kernel applications are

    applications without a graphical user interface. These type of

    applications are used at the console or as server processes.

    The \a argc and \a argv arguments are processed by the application,

    and made available in a more convenient form by the arguments()

    function.

    \warning The data referred to by \a argc and \a argv must stay valid

    for the entire lifetime of the QCoreApplication object. In addition,

    \a argc must be greater than zero and \a argv must contain at least

    one valid character string.

*/

QCoreApplication::QCoreApplication(int &argc, char **argv)

    : QObject(*new QCoreApplicationPrivate(argc, argv))

{

    init();

    QCoreApplicationPrivate::eventDispatcher->startingUp();

#if defined(Q_OS_SYMBIAN) && !defined(QT_NO_LIBRARY)

    // Refresh factoryloader, as text codecs are requested during lib path

    // resolving process and won't be therefore properly loaded.

    // Unknown if this is symbian specific issue.

    QFactoryLoader::refreshAll();

#endif

#if defined(Q_OS_SYMBIAN) && !defined(QT_NO_SYSTEMLOCALE)

    d_func()->symbianInit();

#endif