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

**

** 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 QtGui 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 "qglobal.h"

#include "qlibrary.h"

#include "qcursor.h"

#include "qapplication.h"

#include "private/qapplication_p.h"

#include "qwidget.h"

#include "qbitarray.h"

#include "qpainter.h"

#include "qpixmapcache.h"

#include "qdatetime.h"

#include "qtextcodec.h"

#include "qdatastream.h"

#include "qbuffer.h"

#include "qsocketnotifier.h"

#include "qsessionmanager.h"

#include "qclipboard.h"

#include "qbitmap.h"

#include "qwssocket_qws.h"

#include "qtransportauth_qws.h"

#include "private/qtransportauth_qws_p.h"

#include "qwsevent_qws.h"

#include "private/qwscommand_qws_p.h"

#include "qwsproperty_qws.h"

#include "qscreen_qws.h"

#include "qscreenproxy_qws.h"

#include "qcopchannel_qws.h"

#include "private/qlock_p.h"

#include "private/qwslock_p.h"

//#include "qmemorymanager_qws.h"

#include "qwsmanager_qws.h"

//#include "qwsregionmanager_qws.h"

#include "qwindowsystem_qws.h"

#include "private/qwindowsystem_p.h"

#include "qdecorationfactory_qws.h"

#include "qwsdisplay_qws.h"

#include "private/qwsdisplay_qws_p.h"

#include "private/qwsinputcontext_p.h"

#include "qfile.h"

#include "qhash.h"

#include "qdesktopwidget.h"

#include "qcolormap.h"

#include "private/qcursor_p.h"

#include "qsettings.h"

#include "qdebug.h"

#include "qeventdispatcher_qws_p.h"

#if !defined(QT_NO_GLIB)

#  include "qeventdispatcher_glib_qws_p.h"

#endif

#include "private/qwidget_p.h"

#include "private/qbackingstore_p.h"

#include "private/qwindowsurface_qws_p.h"

#include "private/qfont_p.h"

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <locale.h>

#include <errno.h>

#include <fcntl.h>

#ifdef Q_OS_VXWORKS

#  include <sys/times.h>

#else

#  include <sys/time.h>

#endif

#include <sys/stat.h>

#include <sys/types.h>

#include <qvfbhdr.h>

#ifndef QT_NO_QWS_MULTIPROCESS

#ifdef QT_NO_QSHM

#include <sys/ipc.h>

#include <sys/shm.h>

#ifndef Q_OS_DARWIN

# include <sys/sem.h>

#endif

#include <sys/socket.h>

#else

#include "private/qwssharedmemory_p.h"

#endif

#endif

QT_BEGIN_NAMESPACE

#ifndef QT_NO_DIRECTPAINTER

class QDirectPainter;

extern void qt_directpainter_region(QDirectPainter *dp, const QRegion &alloc, int type);

#ifndef QT_NO_QWSEMBEDWIDGET

extern void qt_directpainter_embedevent(QDirectPainter *dp,

                                        const QWSEmbedEvent *e);

#endif

#endif // QT_NO_DIRECTPAINTER

const int qwsSharedRamSize = 1 * 1024; // misc data, written by server, read by clients

extern QApplication::Type qt_appType;

extern QDesktopWidget *qt_desktopWidget;

//these used to be environment variables, they are initialized from

//environment variables in

bool qws_savefonts = false;

bool qws_screen_is_interlaced=false; //### should be detected

bool qws_shared_memory = false;

bool qws_sw_cursor = true;

bool qws_accel = true;            // ### never set

QByteArray qws_display_spec(":0");

Q_GUI_EXPORT int qws_display_id = 0;

Q_GUI_EXPORT int qws_client_id = 0;

QWidget *qt_pressGrab = 0;

QWidget *qt_mouseGrb = 0;

int *qt_last_x = 0;

int *qt_last_y = 0;

static int mouse_x_root = -1;

static int mouse_y_root = -1;

static int mouse_state = 0;

static int mouse_double_click_distance = 5;

int qt_servershmid = -1;

bool qws_overrideCursor = false;

#ifndef QT_NO_QWS_MANAGER

extern Q_GUI_EXPORT QWSServer *qwsServer;

static QDecoration *qws_decoration = 0;

#endif

#if defined(QT_DEBUG)

/*

extern "C" void dumpmem(const char* m)

{

    static int init=0;

    static int prev=0;

    FILE* f = fopen("/proc/meminfo","r");

    //    char line[100];

    int total=0,used=0,free=0,shared=0,buffers=0,cached=0;

    fscanf(f,"%*[^M]Mem: %d %d %d %d %d %d",&total,&used,&free,&shared,&buffers,&cached);

    used -= buffers + cached;

    if (!init) {

        init=used;

    } else {

        printf("%40s: %+8d = %8d\n",m,used-init-prev,used-init);

        prev = used-init;

    }

    fclose(f);

}

*/

#endif

// Get the name of the directory where Qt for Embedded Linux temporary data should

// live.

QString qws_dataDir()

{

    static QString result;

    if (!result.isEmpty())

        return result;

    result = QT_VFB_DATADIR(qws_display_id);

    QByteArray dataDir = result.toLocal8Bit();

    if (QT_MKDIR(dataDir, 0700)) {

        if (errno != EEXIST) {

            qFatal("Cannot create Qt for Embedded Linux data directory: %s", dataDir.constData());

        }

    }

    QT_STATBUF buf;

    if (QT_LSTAT(dataDir, &buf))

        qFatal("stat failed for Qt for Embedded Linux data directory: %s", dataDir.constData());

    if (!S_ISDIR(buf.st_mode))

        qFatal("%s is not a directory", dataDir.constData());

#if !defined(Q_OS_INTEGRITY) && !defined(Q_OS_VXWORKS)

    if (buf.st_uid != getuid())

        qFatal("Qt for Embedded Linux data directory is not owned by user %d", getuid());

    if ((buf.st_mode & 0677) != 0600)

        qFatal("Qt for Embedded Linux data directory has incorrect permissions: %s", dataDir.constData());

#endif

    result.append("/");

    return result;

}

// Get the filename of the pipe Qt for Embedded Linux uses for server/client comms

Q_GUI_EXPORT QString qws_qtePipeFilename()

{

    qws_dataDir();

    return QTE_PIPE(qws_display_id);

}

static void setMaxWindowRect(const QRect &rect)

{

    const QList<QScreen*> subScreens = qt_screen->subScreens();

    QScreen *screen = qt_screen;

    int screenNo = 0;

    for (int i = 0; i < subScreens.size(); ++i) {

        if (subScreens.at(i)->region().contains(rect)) {

            screen = subScreens.at(i);

            screenNo = i;

            break;

        }

    }

    QApplicationPrivate *ap = QApplicationPrivate::instance();

    ap->setMaxWindowRect(screen, screenNo, rect);

}

void QApplicationPrivate::setMaxWindowRect(const QScreen *screen, int screenNo,

                                           const QRect &rect)

{

    if (maxWindowRects.value(screen) == rect)

        return;

    maxWindowRects[screen] = rect;

    // Re-resize any maximized windows

    QWidgetList l = QApplication::topLevelWidgets();

    for (int i = 0; i < l.size(); ++i) {

        QWidget *w = l.at(i);

        QScreen *s = w->d_func()->getScreen();

        if (w->isMaximized() && s == screen)

            w->d_func()->setMaxWindowState_helper();

    }

    if ( qt_desktopWidget ) // XXX workaround crash

        emit QApplication::desktop()->workAreaResized(screenNo);

}

#ifndef QT_NO_QWS_DYNAMICSCREENTRANSFORMATION

typedef void (*TransformFunc)(QScreen *, int);

#ifndef QT_NO_QWS_TRANSFORMED

extern "C" void qws_setScreenTransformation(QScreen *, int);

#endif

static TransformFunc getTransformationFunction()

{

    static TransformFunc func = 0;

    if (!func) {

#ifdef QT_NO_QWS_TRANSFORMED

#  ifndef QT_NO_LIBRARY

        // symbol is not built into the library, search for the plugin

        const QStringList paths = QApplication::libraryPaths();

        foreach (const QString &path, paths) {

            const QString file = path + QLatin1String("/gfxdrivers/libqgfxtransformed");

            func = (TransformFunc)QLibrary::resolve(file,

                                                    "qws_setScreenTransformation");

            if (func)

                break;

        }

#  endif

#else

        func = qws_setScreenTransformation;

#endif

        if (!func)

            func = (TransformFunc)-1;

    }

    if (func == (TransformFunc)-1)

        return 0;

    return func;

}

static void setScreenTransformation(int screenNo, int transformation)

{

    QScreen *screen = QScreen::instance();

    const QList<QScreen*> subScreens = screen->subScreens();

    if (screenNo == -1)

        screenNo = 0;

    if (screenNo == -1 && !subScreens.isEmpty())

        screenNo = 0;

    if (subScreens.isEmpty() && screenNo == 0) {

        // nothing

    } else if (screenNo < 0 || screenNo >= subScreens.size()) {

        qWarning("setScreenTransformation: invalid screen %i", screenNo);

        return;

    }

    if (screenNo < subScreens.size())

        screen = subScreens.at(screenNo);

    QApplicationPrivate *ap = QApplicationPrivate::instance();

    ap->setScreenTransformation(screen, screenNo, transformation);

}

void QApplicationPrivate::setScreenTransformation(QScreen *screen,

                                                  int screenNo,

                                                  int transformation)

{

    QScreen *transformed = screen;

    while (transformed->classId() == QScreen::ProxyClass)

        transformed = static_cast<QProxyScreen*>(transformed)->screen();

    if (transformed->classId() != QScreen::TransformedClass)

        return;

    TransformFunc setScreenTransformation = getTransformationFunction();

    if (!setScreenTransformation)

        return;

    setScreenTransformation(transformed, transformation);

    // need to re-configure() proxies bottom-up

    if (screen->classId() == QScreen::ProxyClass) {

        QList<QProxyScreen*> proxies;

        QScreen *s = screen;

        do {

            QProxyScreen *proxy = static_cast<QProxyScreen*>(s);

            proxies.append(proxy);

            s = proxy->screen();

        } while (s->classId() == QScreen::ProxyClass);

        do {

            QProxyScreen *proxy = proxies.takeLast();

            proxy->setScreen(proxy->screen()); // triggers configure()

        } while (!proxies.isEmpty());

    }

    if (qt_desktopWidget) { // XXX workaround crash for early screen transform events

        QDesktopWidget *desktop = QApplication::desktop();

        emit desktop->resized(screenNo);

        if (maxWindowRect(screen).isEmpty()) // not explicitly set

            emit desktop->workAreaResized(screenNo);

    }

    QWSServer *server = QWSServer::instance();

    if (server) {

        server->updateWindowRegions();

        QRegion r = screen->region();

        server->refresh(r);

    }

    // make sure maximized and fullscreen windows are updated

    QWidgetList list = QApplication::topLevelWidgets();

    for (int i = list.size() - 1; i >= 0; --i) {

        QWidget *w = list.at(i);

        if (w->isFullScreen())

            w->d_func()->setFullScreenSize_helper();

        else if (w->isMaximized())

            w->d_func()->setMaxWindowState_helper();

    }

}

#endif // QT_NO_QWS_DYNAMICSCREENTRANSFORMATION

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

  Internal variables and functions

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

static QString appName;                          // application name

static const char *appFont = 0;                  // application font

static const char *appBGCol = 0;                 // application bg color

static const char *appFGCol = 0;                 // application fg color

static const char *appBTNCol = 0;                // application btn color

static const char *mwGeometry = 0;               // main widget geometry

static const char *mwTitle = 0;                  // main widget title

//static bool mwIconic = false;                  // main widget iconified

static bool app_do_modal = false;                // modal mode

Q_GUI_EXPORT QWSDisplay *qt_fbdpy = 0;                        // QWS `display'

QLock *QWSDisplay::lock = 0;

static int mouseButtonPressed = 0;               // last mouse button pressed

static int mouseButtonPressTime = 0;             // when was a button pressed

static short mouseXPos, mouseYPos;               // mouse position in act window

extern QWidgetList *qt_modal_stack;              // stack of modal widgets

static QWidget *popupButtonFocus = 0;

static QWidget *popupOfPopupButtonFocus = 0;

static bool popupCloseDownMode = false;

static bool popupGrabOk;

static QPointer<QWidget> *mouseInWidget = 0;

QPointer<QWidget> qt_last_mouse_receiver = 0;

static bool sm_blockUserInput = false;           // session management

QWidget *qt_button_down = 0;                     // widget got last button-down

WId qt_last_cursor = 0xffffffff;                 // Was -1, but WIds are unsigned

class QWSMouseEvent;

class QWSKeyEvent;

class QETWidget : public QWidget                 // event translator widget

{

public:

    bool translateMouseEvent(const QWSMouseEvent *, int oldstate);

    bool translateKeyEvent(const QWSKeyEvent *, bool grab);

    bool translateRegionEvent(const QWSRegionEvent *);

#ifndef QT_NO_QWSEMBEDWIDGET

    void translateEmbedEvent(const QWSEmbedEvent *event);

#endif

    bool translateWheelEvent(const QWSMouseEvent *me);

    void repaintDecoration(QRegion r, bool post);

    void updateRegion();

    bool raiseOnClick()

    {

        // With limited windowmanagement/taskbar/etc., raising big windows

        // (eg. spreadsheet) over the top of everything else (eg. calculator)

        // is just annoying.

        return !isMaximized() && !isFullScreen();

    }

};

void QApplicationPrivate::createEventDispatcher()

{

    Q_Q(QApplication);

#if !defined(QT_NO_GLIB)

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

        eventDispatcher = (q->type() != QApplication::Tty

                           ? new QWSEventDispatcherGlib(q)

                           : new QEventDispatcherGlib(q));

    else

#endif

    eventDispatcher = (q->type() != QApplication::Tty

                       ? new QEventDispatcherQWS(q)

                       : new QEventDispatcherUNIX(q));

}

// Single-process stuff. This should maybe move into qwindowsystem_qws.cpp

static bool qws_single_process;

static QList<QWSEvent*> incoming;

static QList<QWSCommand*> outgoing;

void qt_client_enqueue(const QWSEvent *event)

{

    QWSEvent *copy = QWSEvent::factory(event->type);

    copy->copyFrom(event);

    incoming.append(copy);

}

QList<QWSCommand*> *qt_get_server_queue()

{

    return &outgoing;

}

void qt_server_enqueue(const QWSCommand *command)

{

    QWSCommand *copy = QWSCommand::factory(command->type);

    QT_TRY {

        copy->copyFrom(command);

        outgoing.append(copy);

    } QT_CATCH(...) {

        delete copy;

        QT_RETHROW;

    }

}

QWSDisplay::Data::Data(QObject* parent, bool singleProcess)

{

#ifdef QT_NO_QWS_MULTIPROCESS

    Q_UNUSED(parent);

    Q_UNUSED(singleProcess);

#else

    if (singleProcess)

        csocket = 0;

    else {

        csocket = new QWSSocket(parent);

        QObject::connect(csocket, SIGNAL(disconnected()),

                         qApp, SLOT(quit()));

    }

    clientLock = 0;

#endif

    init();

}

QWSDisplay::Data::~Data()

{

//        delete rgnMan; rgnMan = 0;

//        delete memorymanager; memorymanager = 0;