- QtSvg R: QtXml, QtSvg-devel R: QtXml-devel

[packages/qt4.git] / qt4-tools.patch

--- qt-copy/tools/tools.pro.orig	2005-05-13 16:39:18.000000000 +0200
+++ qt-copy/tools/tools.pro	2005-05-13 20:02:31.761482520 +0200
@@ -7,7 +7,7 @@
 			assistant \
 			porting \
                         qtestlib \
-			pixeltool
+			pixeltool qvfb
     contains(QT_EDITION, Console) {
         SUBDIRS += designer/src/uitools     # Linguist depends on this
     } else {
diff -Nur qt-x11-opensource-src-4.1.4/src/gui/embedded.orig/qlock.cpp qt-x11-opensource-src-4.1.4/src/gui/embedded/qlock.cpp
--- qt-x11-opensource-src-4.1.4/src/gui/embedded.orig/qlock.cpp	1970-01-01 01:00:00.000000000 +0100
+++ qt-x11-opensource-src-4.1.4/src/gui/embedded/qlock.cpp	2006-07-02 11:35:54.386518000 +0200
@@ -0,0 +1,289 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2006 Trolltech AS. All rights reserved.
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of
+** this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+** http://www.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.com.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#include "qlock_p.h"
+
+#ifndef QT_NO_QWS_MULTIPROCESS
+
+#include <unistd.h>
+#include <sys/types.h>
+#if defined(Q_OS_DARWIN)
+#define Q_NO_SEMAPHORE
+#include <sys/stat.h>
+#include <sys/file.h>
+#else
+#include <sys/sem.h>
+#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED) \
+    || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD) || defined(Q_OS_NETBSD) || defined(Q_OS_BSDI)
+/* union semun is defined by including <sys/sem.h> */
+#else
+/* according to X/OPEN we have to define it ourselves */
+union semun {
+    int val;                    /* value for SETVAL */
+    struct semid_ds *buf;       /* buffer for IPC_STAT, IPC_SET */
+    unsigned short *array;      /* array for GETALL, SETALL */
+};
+#endif
+#endif
+#include <sys/ipc.h>
+#include <string.h>
+#include <errno.h>
+#include <qdebug.h>
+
+#define MAX_LOCKS   200            // maximum simultaneous read locks
+
+class QLockData
+{
+public:
+#ifdef Q_NO_SEMAPHORE
+    QByteArray file;
+#endif
+    int id;
+    int count;
+    bool owned;
+};
+
+#endif
+
+/*!
+    \class QLock qlock_p.h
+    \brief The QLock class is a wrapper for a System V shared semaphore.
+
+    \ingroup qws
+    \ingroup io
+
+    \internal
+
+    It is used by \l {Qtopia Core} for synchronizing access to the graphics
+    card and shared memory region between processes.
+*/
+
+/*!
+    \enum QLock::Type
+
+    \value Read
+    \value Write
+*/
+
+/*!
+    \fn QLock::QLock(const QString &filename, char id, bool create)
+
+    Creates a lock. \a filename is the file path of the Unix-domain
+    socket the \l {Qtopia Core} client is using. \a id is the name of the
+    particular lock to be created on that socket. If \a create is true
+    the lock is to be created (as the \l {Qtopia Core} server does); if \a
+    create is false the lock should exist already (as the \l {Qtopia Core}
+    client expects).
+*/
+
+QLock::QLock(const QString &filename, char id, bool create)
+{
+#ifdef QT_NO_QWS_MULTIPROCESS
+    Q_UNUSED(filename);
+    Q_UNUSED(id);
+    Q_UNUSED(create);
+#else
+    data = new QLockData;
+    data->count = 0;
+#ifdef Q_NO_SEMAPHORE
+    data->file = QString(filename+id).toLocal8Bit().constData();
+    for(int x = 0; x < 2; x++) {
+        data->id = open(data->file, O_RDWR | (x ? O_CREAT : 0), S_IRWXU);
+        if(data->id != -1 || !create) {
+            data->owned = x;
+            break;
+        }
+    }
+#else
+    key_t semkey = ftok(filename.toLocal8Bit().constData(), id);
+    data->id = semget(semkey,0,0);
+    data->owned = create;
+    if (create) {
+        semun arg; arg.val = 0;
+        if (data->id != -1)
+            semctl(data->id,0,IPC_RMID,arg);
+        data->id = semget(semkey,1,IPC_CREAT|0600);
+        arg.val = MAX_LOCKS;
+        semctl(data->id,0,SETVAL,arg);
+    }
+#endif
+    if (data->id == -1) {
+        qWarning("Cannot %s semaphore %s '%c'", (create ? "create" : "get"),
+                 qPrintable(filename), id);
+        qDebug() << "Error" << errno << strerror(errno);
+    }
+#endif
+}
+
+/*!
+    \fn QLock::~QLock()
+
+    Destroys a lock
+*/
+
+QLock::~QLock()
+{
+#ifndef QT_NO_QWS_MULTIPROCESS
+    if (locked())
+        unlock();
+#ifdef Q_NO_SEMAPHORE
+    if(isValid()) {
+        close(data->id);
+        if(data->owned)
+            unlink(data->file);
+    }
+#else
+    if(data->owned) {
+        semun arg; arg.val = 0;
+        semctl(data->id, 0, IPC_RMID, arg);
+    }
+#endif
+    delete data;
+#endif
+}
+
+/*!
+    \fn bool QLock::isValid() const
+
+    Returns true if the lock constructor was successful; returns false if
+    the lock could not be created or was not available to connect to.
+*/
+
+bool QLock::isValid() const
+{
+#ifndef QT_NO_QWS_MULTIPROCESS
+    return (data->id != -1);
+#else
+    return true;
+#endif
+}
+
+/*!
+    Locks the semaphore with a lock of type \a t. Locks can either be
+    \c Read or \c Write. If a lock is \c Read, attempts by other
+    processes to obtain \c Read locks will succeed, and \c Write
+    attempts will block until the lock is unlocked. If locked as \c
+    Write, all attempts to lock by other processes will block until
+    the lock is unlocked. Locks are stacked: i.e. a given QLock can be
+    locked multiple times by the same process without blocking, and
+    will only be unlocked after a corresponding number of unlock()
+    calls.
+*/
+
+void QLock::lock(Type t)
+{
+#ifdef QT_NO_QWS_MULTIPROCESS
+    Q_UNUSED(t);
+#else
+    if (!data->count) {
+#ifdef Q_NO_SEMAPHORE
+        int op = LOCK_SH;
+        if(t == Write)
+            op = LOCK_EX;
+        for(int rv=1; rv;) {
+            rv = flock(data->id, op);
+            if (rv == -1 && errno != EINTR)
+                qDebug("Semop lock failure %s",strerror(errno));
+        }
+#else
+        sembuf sops;
+        sops.sem_num = 0;
+        sops.sem_flg = SEM_UNDO;
+
+        if (t == Write) {
+            sops.sem_op = -MAX_LOCKS;
+            type = Write;
+        } else {
+            sops.sem_op = -1;
+            type = Read;
+        }
+
+        int rv;
+        do {
+            rv = semop(data->id,&sops,1);
+            if (rv == -1 && errno != EINTR)
+                qDebug("Semop lock failure %s",strerror(errno));
+        } while (rv == -1 && errno == EINTR);
+#endif
+    }
+    data->count++;
+#endif
+}
+
+/*!
+    \fn void QLock::unlock()
+
+    Unlocks the semaphore. If other processes were blocking waiting to
+    lock() the semaphore, one of them will wake up and succeed in
+    lock()ing.
+*/
+
+void QLock::unlock()
+{
+#ifndef QT_NO_QWS_MULTIPROCESS
+    if(data->count) {
+        data->count--;
+        if(!data->count) {
+#ifdef Q_NO_SEMAPHORE
+            for(int rv=1; rv;) {
+                rv = flock(data->id, LOCK_UN);
+                if (rv == -1 && errno != EINTR)
+                    qDebug("Semop lock failure %s",strerror(errno));
+            }
+#else
+            sembuf sops;
+            sops.sem_num = 0;
+            sops.sem_op = 1;
+            sops.sem_flg = SEM_UNDO;
+            if (type == Write)
+                sops.sem_op = MAX_LOCKS;
+
+            int rv;
+            do {
+                rv = semop(data->id,&sops,1);
+                if (rv == -1 && errno != EINTR)
+                    qDebug("Semop unlock failure %s",strerror(errno));
+            } while (rv == -1 && errno == EINTR);
+#endif
+        }
+    } else {
+        qDebug("Unlock without corresponding lock");
+    }
+#endif
+}
+
+/*!
+    \fn bool QLock::locked() const
+
+    Returns true if the lock is currently held by the current process;
+    otherwise returns false.
+*/
+
+bool QLock::locked() const
+{
+#ifndef QT_NO_QWS_MULTIPROCESS
+    return (data->count > 0);
+#else
+    return false;
+#endif
+}
diff -Nur qt-x11-opensource-src-4.1.4/src/gui/embedded.orig/qlock_p.h qt-x11-opensource-src-4.1.4/src/gui/embedded/qlock_p.h
--- qt-x11-opensource-src-4.1.4/src/gui/embedded.orig/qlock_p.h	1970-01-01 01:00:00.000000000 +0100
+++ qt-x11-opensource-src-4.1.4/src/gui/embedded/qlock_p.h	2006-07-02 11:36:23.952365750 +0200
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2006 Trolltech AS. All rights reserved.
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of
+** this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+** http://www.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.com.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#ifndef QLOCK_P_H
+#define QLOCK_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  This header file may
+// change from version to version without notice, or even be
+// removed.
+//
+// We mean it.
+//
+
+#include "QtCore/qstring.h"
+
+class QLockData;
+
+class Q_GUI_EXPORT QLock
+{
+public:
+    QLock(const QString &filename, char id, bool create = false);
+    ~QLock();
+
+    enum Type { Read, Write };
+
+    bool isValid() const;
+    void lock(Type type);
+    void unlock();
+    bool locked() const;
+
+private:
+    Type type;
+    QLockData *data;
+};
+
+
+// Nice class for ensuring the lock is released.
+// Just create one on the stack and the lock is automatically released
+// when QLockHandle is destructed.
+class Q_GUI_EXPORT QLockHandle
+{
+public:
+    QLockHandle(QLock *l, QLock::Type type) : qlock(l) { qlock->lock(type); }
+    ~QLockHandle() { if (locked()) qlock->unlock(); }
+
+    void lock(QLock::Type type) { qlock->lock(type); }
+    void unlock() { qlock->unlock(); }
+    bool locked() const { return qlock->locked(); }
+
+private:
+    QLock *qlock;
+};
+
+#endif // QLOCK_P_H