SOURCES: qt4-tools.patch - add files needed by qvfb which have bee...
qboosh
qboosh at pld-linux.org
Sun Jul 2 20:43:19 CEST 2006
Author: qboosh Date: Sun Jul 2 18:43:19 2006 GMT
Module: SOURCES Tag: HEAD
---- Log message:
- add files needed by qvfb which have been removed from qt 4.1.4 sources
---- Files affected:
SOURCES:
qt4-tools.patch (1.5 -> 1.6)
---- Diffs:
================================================================
Index: SOURCES/qt4-tools.patch
diff -u SOURCES/qt4-tools.patch:1.5 SOURCES/qt4-tools.patch:1.6
--- SOURCES/qt4-tools.patch:1.5 Thu Jan 12 02:30:09 2006
+++ SOURCES/qt4-tools.patch Sun Jul 2 20:43:14 2006
@@ -9,3 +9,444 @@
!contains(QT_EDITION, Console):SUBDIRS += designer
unix:!embedded:SUBDIRS += qtconfig
win32:!contains(QT_EDITION, OpenSource|Console):SUBDIRS += activeqt
+--- qt-x11-opensource-src-4.1.4/tools/qvfb/qvfbhdr.h.orig 1970-01-01 01:00:00.000000000 +0100
++++ qt-x11-opensource-src-4.1.4/tools/qvfb/qvfbhdr.h 2006-07-02 11:34:33.753478750 +0200
+@@ -0,0 +1,63 @@
++/****************************************************************************
++**
++** 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 at 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 QVFBHDR_H
++#define QVFBHDR_H
++
++#include <QtGui/qcolor.h>
++#include <QtCore/qrect.h>
++
++QT_BEGIN_HEADER
++
++QT_MODULE(Gui)
++
++#define QT_VFB_MOUSE_PIPE "/tmp/.qtvfb_mouse-%1"
++#define QT_VFB_KEYBOARD_PIPE "/tmp/.qtvfb_keyboard-%1"
++
++struct QVFbHeader
++{
++ int width;
++ int height;
++ int depth;
++ int linestep;
++ int dataoffset;
++ QRect update;
++ bool dirty;
++ int numcols;
++ QRgb clut[256];
++ int viewerVersion;
++ int serverVersion;
++};
++
++struct QVFbKeyData
++{
++ unsigned int keycode;
++ Qt::KeyboardModifiers modifiers;
++ unsigned short int unicode;
++ bool press;
++ bool repeat;
++};
++
++QT_END_HEADER
++
++#endif // QVFBHDR_H
+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 at 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 at 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
================================================================
---- CVS-web:
http://cvs.pld-linux.org/SOURCES/qt4-tools.patch?r1=1.5&r2=1.6&f=u
More information about the pld-cvs-commit
mailing list