diff options
Diffstat (limited to 'src/qt3support/other')
22 files changed, 8506 insertions, 0 deletions
diff --git a/src/qt3support/other/other.pri b/src/qt3support/other/other.pri new file mode 100644 index 0000000..b2b0e56 --- /dev/null +++ b/src/qt3support/other/other.pri @@ -0,0 +1,24 @@ +# Qt compat module + +HEADERS += other/q3dropsite.h \ + other/q3dragobject.h \ + other/q3accel.h \ + other/q3mimefactory.h \ + other/q3polygonscanner.h \ + other/q3process.h \ + other/q3membuf_p.h \ + other/q3boxlayout.h \ + other/q3gridlayout.h + +SOURCES += other/q3dropsite.cpp \ + other/q3dragobject.cpp \ + other/q3accel.cpp \ + other/q3mimefactory.cpp \ + other/q3polygonscanner.cpp \ + other/q3process.cpp \ + other/q3membuf.cpp + +unix:SOURCES += other/q3process_unix.cpp +win32:SOURCES+= other/q3process_win.cpp + + diff --git a/src/qt3support/other/q3accel.cpp b/src/qt3support/other/q3accel.cpp new file mode 100644 index 0000000..a570a70 --- /dev/null +++ b/src/qt3support/other/q3accel.cpp @@ -0,0 +1,982 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3accel.h" + +#include "q3signal.h" +#include "qapplication.h" +#include "qwidget.h" +#include "q3ptrlist.h" +#include "qwhatsthis.h" +#include "qpointer.h" +#include "qstatusbar.h" +#include "qdockwidget.h" +#include "qevent.h" +#include "qkeysequence.h" +#include "private/qapplication_p.h" + +QT_BEGIN_NAMESPACE + +using namespace Qt; + +/*! + \class Q3Accel + \brief The Q3Accel class handles keyboard accelerator and shortcut keys. + + \compat + + A keyboard accelerator triggers an action when a certain key + combination is pressed. The accelerator handles all keyboard + activity for all the children of one top-level widget, so it is + not affected by the keyboard focus. + + In most cases, you will not need to use this class directly. Use + the QAction class to create actions with accelerators that can be + used in both menus and toolbars. If you're only interested in + menus use Q3MenuData::insertItem() or Q3MenuData::setAccel() to make + accelerators for operations that are also available on menus. Many + widgets automatically generate accelerators, such as QAbstractButton, + QGroupBox, QLabel (with QLabel::setBuddy()), QMenuBar, and QTabBar. + Example: + \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 0 + + A Q3Accel contains a list of accelerator items that can be + manipulated using insertItem(), removeItem(), clear(), key() and + findKey(). + + Each accelerator item consists of an identifier and a \l + QKeySequence. A single key sequence consists of a keyboard code + combined with modifiers (Qt::SHIFT, Qt::CTRL, Qt::ALT, or + Qt::UNICODE_ACCEL). For example, Qt::CTRL + Qt::Key_P could be a shortcut + for printing a document. As an alternative, use Qt::UNICODE_ACCEL with the + unicode code point of the character. For example, Qt::UNICODE_ACCEL + + 'A' gives the same accelerator as Qt::Key_A. + + When an accelerator key is pressed, the accelerator sends out the + signal activated() with a number that identifies this particular + accelerator item. Accelerator items can also be individually + connected, so that two different keys will activate two different + slots (see connectItem() and disconnectItem()). + + The activated() signal is \e not emitted when two or more + accelerators match the same key. Instead, the first matching + accelerator sends out the activatedAmbiguously() signal. By + pressing the key multiple times, users can navigate between all + matching accelerators. Some standard controls like QPushButton and + QCheckBox connect the activatedAmbiguously() signal to the + harmless setFocus() slot, whereas activated() is connected to a + slot invoking the button's action. Most controls, like QLabel and + QTabBar, treat activated() and activatedAmbiguously() as + equivalent. + + Use setEnabled() to enable or disable all the items in an + accelerator, or setItemEnabled() to enable or disable individual + items. An item is active only when both the Q3Accel and the item + itself are enabled. + + The function setWhatsThis() specifies a help text that appears + when the user presses an accelerator key in What's This mode. + + The accelerator will be deleted when \e parent is deleted, + and will consume relevant key events until then. + + Please note that the accelerator + \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 1 + can be triggered with both the 'M' key, and with Shift+M, + unless a second accelerator is defined for the Shift+M + combination. + + + Example: + \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 2 + + \sa QKeyEvent QWidget::keyPressEvent() + QAbstractButton::setAccel() QLabel::setBuddy() QKeySequence +*/ + + +struct Q3AccelItem { // internal accelerator item + Q3AccelItem(const QKeySequence &k, int i) + { key=k; id=i; enabled=true; signal=0; } + ~Q3AccelItem() { delete signal; } + int id; + QKeySequence key; + bool enabled; + Q3Signal *signal; + QString whatsthis; +}; + + +typedef Q3PtrList<Q3AccelItem> Q3AccelList; // internal accelerator list + +class Q3AccelPrivate { +public: + Q3AccelPrivate(Q3Accel* p); + ~Q3AccelPrivate(); + Q3AccelList aitems; + bool enabled; + QPointer<QWidget> watch; + bool ignorewhatsthis; + Q3Accel* parent; + + void activate(Q3AccelItem* item); + void activateAmbiguously(Q3AccelItem* item); +}; + +class Q3AccelManager { +public: + static Q3AccelManager* self() { return self_ptr ? self_ptr : new Q3AccelManager; } + void registerAccel(Q3AccelPrivate* a) { accels.append(a); } + void unregisterAccel(Q3AccelPrivate* a) { accels.removeRef(a); if (accels.isEmpty()) delete this; } + bool tryAccelEvent(QWidget* w, QKeyEvent* e); + bool dispatchAccelEvent(QWidget* w, QKeyEvent* e); + bool tryComposeUnicode(QWidget* w, QKeyEvent* e); + +private: + Q3AccelManager() + : currentState(QKeySequence::NoMatch), clash(-1), metaComposeUnicode(false),composedUnicode(0) + { setFuncPtr(); self_ptr = this; } + ~Q3AccelManager() { self_ptr = 0; } + void setFuncPtr(); + + bool correctSubWindow(QWidget *w, Q3AccelPrivate* d); + QKeySequence::SequenceMatch match(QKeyEvent* e, Q3AccelItem* item, QKeySequence& temp); + int translateModifiers(ButtonState state); + + Q3PtrList<Q3AccelPrivate> accels; + static Q3AccelManager* self_ptr; + QKeySequence::SequenceMatch currentState; + QKeySequence intermediate; + int clash; + bool metaComposeUnicode; + int composedUnicode; +}; +Q3AccelManager* Q3AccelManager::self_ptr = 0; + +bool Q_COMPAT_EXPORT qt_tryAccelEvent(QWidget* w, QKeyEvent* e){ + return Q3AccelManager::self()->tryAccelEvent(w, e); +} + +bool Q_COMPAT_EXPORT qt_dispatchAccelEvent(QWidget* w, QKeyEvent* e){ + return Q3AccelManager::self()->dispatchAccelEvent(w, e); +} + +bool Q_COMPAT_EXPORT qt_tryComposeUnicode(QWidget* w, QKeyEvent* e){ + return Q3AccelManager::self()->tryComposeUnicode(w, e); +} + +void Q3AccelManager::setFuncPtr() { + if (qApp->d_func()->qt_compat_used) + return; + QApplicationPrivate *data = static_cast<QApplicationPrivate*>(qApp->d_ptr); + data->qt_tryAccelEvent = qt_tryAccelEvent; + data->qt_tryComposeUnicode = qt_tryComposeUnicode; + data->qt_dispatchAccelEvent = qt_dispatchAccelEvent; + data->qt_compat_used = true; +} + +#ifdef Q_WS_MAC +static bool qt_accel_no_shortcuts = true; +#else +static bool qt_accel_no_shortcuts = false; +#endif +void Q_COMPAT_EXPORT qt_set_accel_auto_shortcuts(bool b) { qt_accel_no_shortcuts = b; } + +/* + \internal + Returns true if the accel is in the current subwindow, else false. +*/ +bool Q3AccelManager::correctSubWindow(QWidget* w, Q3AccelPrivate* d) { +#if !defined (Q_OS_MACX) + if (!d->watch || !d->watch->isVisible() || !d->watch->isEnabled()) +#else + if (!d->watch || (!d->watch->isVisible() && !d->watch->inherits("QMenuBar")) || !d->watch->isEnabled()) +#endif + return false; + QWidget* tlw = w->window(); + QWidget* wtlw = d->watch->window(); + + /* if we live in a floating dock window, keep our parent's + * accelerators working */ +#ifndef QT_NO_MAINWINDOW + if ((tlw->windowType() == Qt::Dialog) && tlw->parentWidget() && qobject_cast<QDockWidget*>(tlw)) + return tlw->parentWidget()->window() == wtlw; + + if (wtlw != tlw) + return false; +#endif + /* if we live in a MDI subwindow, ignore the event if we are + not the active document window */ + QWidget* sw = d->watch; + while (sw && sw->windowType() != Qt::SubWindow) + sw = sw->parentWidget(true); + if (sw) { // we are in a subwindow indeed + QWidget* fw = w; + while (fw && fw != sw) + fw = fw->parentWidget(true); + if (fw != sw) // focus widget not in our subwindow + return false; + } + return true; +} + +inline int Q3AccelManager::translateModifiers(ButtonState state) +{ + int result = 0; + if (state & ShiftButton) + result |= SHIFT; + if (state & ControlButton) + result |= CTRL; + if (state & MetaButton) + result |= META; + if (state & AltButton) + result |= ALT; + return result; +} + +/* + \internal + Matches the current intermediate key sequence + the latest + keyevent, with and AccelItem. Returns Identical, + PartialMatch or NoMatch, and fills \a temp with the + resulting key sequence. +*/ +QKeySequence::SequenceMatch Q3AccelManager::match(QKeyEvent *e, Q3AccelItem* item, QKeySequence& temp) +{ + QKeySequence::SequenceMatch result = QKeySequence::NoMatch; + int index = intermediate.count(); + temp = intermediate; + + int modifier = translateModifiers(e->state()); + + if (e->key() && e->key() != Key_unknown) { + int key = e->key() | modifier; + if (e->key() == Key_BackTab) { + /* + In QApplication, we map shift+tab to shift+backtab. + This code here reverts the mapping in a way that keeps + backtab and shift+tab accelerators working, in that + order, meaning backtab has priority.*/ + key &= ~SHIFT; + + temp.setKey(key, index); + if (QKeySequence::NoMatch != (result = temp.matches(item->key))) + return result; + if (e->state() & ShiftButton) + key |= SHIFT; + key = Key_Tab | (key & MODIFIER_MASK); + temp.setKey(key, index); + if (QKeySequence::NoMatch != (result = temp.matches(item->key))) + return result; + } else { + temp.setKey(key, index); + if (QKeySequence::NoMatch != (result = temp.matches(item->key))) + return result; + } + + if (key == Key_BackTab) { + if (e->state() & ShiftButton) + key |= SHIFT; + temp.setKey(key, index); + if (QKeySequence::NoMatch != (result = temp.matches(item->key))) + return result; + } + } + if (!e->text().isEmpty()) { + temp.setKey((int)e->text()[0].unicode() | UNICODE_ACCEL | modifier, index); + result = temp.matches(item->key); + } + return result; +} + +bool Q3AccelManager::tryAccelEvent(QWidget* w, QKeyEvent* e) +{ + if (QKeySequence::NoMatch == currentState) { + e->t = QEvent::AccelOverride; + e->ignore(); + QApplication::sendSpontaneousEvent(w, e); + if (e->isAccepted()) + return false; + } + e->t = QEvent::Accel; + e->ignore(); + QApplication::sendSpontaneousEvent(w, e); + return e->isAccepted(); +} + +bool Q3AccelManager::tryComposeUnicode(QWidget* w, QKeyEvent* e) +{ + if (metaComposeUnicode) { + int value = e->key() - Key_0; + // Ignore acceloverrides so we don't trigger + // accels on keypad when Meta compose is on + if ((e->type() == QEvent::AccelOverride) && + (e->state() == Qt::Keypad + Qt::MetaButton)) { + e->accept(); + // Meta compose start/continue + } else if ((e->type() == QEvent::KeyPress) && + (e->state() == Qt::Keypad + Qt::MetaButton)) { + if (value >= 0 && value <= 9) { + composedUnicode *= 10; + composedUnicode += value; + return true; + } else { + // Composing interrupted, dispatch! + if (composedUnicode) { + QChar ch(composedUnicode); + QString s(ch); + QKeyEvent kep(QEvent::KeyPress, 0, ch.row() ? 0 : ch.cell(), 0, s); + QKeyEvent ker(QEvent::KeyRelease, 0, ch.row() ? 0 : ch.cell(), 0, s); + QApplication::sendEvent(w, &kep); + QApplication::sendEvent(w, &ker); + } + composedUnicode = 0; + return true; + } + // Meta compose end, dispatch + } else if ((e->type() == QEvent::KeyRelease) && + (e->key() == Key_Meta) && + (composedUnicode != 0)) { + if ((composedUnicode > 0) && + (composedUnicode < 0xFFFE)) { + QChar ch(composedUnicode); + QString s(ch); + QKeyEvent kep(QEvent::KeyPress, 0, ch.row() ? 0 : ch.cell(), 0, s); + QKeyEvent ker(QEvent::KeyRelease, 0, ch.row() ? 0 : ch.cell(), 0, s); + QApplication::sendEvent(w, &kep); + QApplication::sendEvent(w, &ker); + } + composedUnicode = 0; + return true; + } + } + return false; +} + +/* + \internal + Checks for possible accelerators, if no widget + ate the keypres, or we are in the middle of a + partial key sequence. +*/ +bool Q3AccelManager::dispatchAccelEvent(QWidget* w, QKeyEvent* e) +{ +#ifndef QT_NO_STATUSBAR + // Needs to be declared and used here because of "goto doclash" + QStatusBar* mainStatusBar = 0; +#endif + + // Modifiers can NOT be accelerators... + if (e->key() >= Key_Shift && + e->key() <= Key_Alt) + return false; + + QKeySequence::SequenceMatch result = QKeySequence::NoMatch; + QKeySequence tocheck, partial; + Q3AccelPrivate* accel = 0; + Q3AccelItem* item = 0; + Q3AccelPrivate* firstaccel = 0; + Q3AccelItem* firstitem = 0; + Q3AccelPrivate* lastaccel = 0; + Q3AccelItem* lastitem = 0; + + QKeyEvent pe = *e; + int n = -1; + int hasShift = (e->state()&Qt::ShiftButton)?1:0; + bool identicalDisabled = false; + bool matchFound = false; + do { + accel = accels.first(); + matchFound = false; + while (accel) { + if (correctSubWindow(w, accel)) { + if (accel->enabled) { + item = accel->aitems.last(); + while(item) { + if (QKeySequence::Identical == (result = match(&pe, item, tocheck))) { + if (item->enabled) { + if (!firstaccel) { + firstaccel = accel; + firstitem = item; + } + lastaccel = accel; + lastitem = item; + n++; + matchFound = true; + if (n > QMAX(clash,0)) + goto doclash; + } else { + identicalDisabled = true; + } + } + if (item->enabled && QKeySequence::PartialMatch == result) { + partial = tocheck; + matchFound = true; + } + item = accel->aitems.prev(); + } + } else { + item = accel->aitems.last(); + while(item) { + if (QKeySequence::Identical == match(&pe, item, tocheck)) + identicalDisabled = true; + item = accel->aitems.prev(); + } + } + } + accel = accels.next(); + } + pe = QKeyEvent(QEvent::Accel, pe.key(), pe.ascii(), pe.state()&~Qt::ShiftButton, pe.text()); + } while (hasShift-- && !matchFound && !identicalDisabled); + +#ifndef QT_NO_STATUSBAR + mainStatusBar = (QStatusBar*) w->window()->child(0, "QStatusBar"); +#endif + if (n < 0) { // no match found + currentState = partial.count() ? QKeySequence::PartialMatch : QKeySequence::NoMatch; +#ifndef QT_NO_STATUSBAR + // Only display message if we are, or were, in a partial match + if (mainStatusBar && (QKeySequence::PartialMatch == currentState || intermediate.count())) { + if (currentState == QKeySequence::PartialMatch) { + mainStatusBar->showMessage((QString)partial + QLatin1String(", ...")); + } else if (!identicalDisabled) { + QString message = Q3Accel::tr("%1, %2 not defined"). + arg((QString)intermediate). + arg(QKeySequence::encodeString(e->key() | translateModifiers(e->state()))); + mainStatusBar->showMessage(message, 2000); + // Since we're a NoMatch, reset the clash count + clash = -1; + } else { + mainStatusBar->clearMessage(); + } + } +#endif + + bool eatKey = (QKeySequence::PartialMatch == currentState || intermediate.count()); + intermediate = partial; + if (eatKey) + e->accept(); + return eatKey; + } else if (n == 0) { // found exactly one match + clash = -1; // reset +#ifndef QT_NO_STATUSBAR + if (currentState == QKeySequence::PartialMatch && mainStatusBar) + mainStatusBar->clearMessage(); +#endif + currentState = QKeySequence::NoMatch; // Free sequence keylock + intermediate = QKeySequence(); + lastaccel->activate(lastitem); + e->accept(); + return true; + } + + doclash: // found more than one match +#ifndef QT_NO_STATUSBAR + if (!mainStatusBar) // if "goto doclash", we need to get status bar again. + mainStatusBar = (QStatusBar*) w->window()->child(0, "QStatusBar"); +#endif + + QString message = Q3Accel::tr("Ambiguous %1 not handled").arg((QString)tocheck); + if (clash >= 0 && n > clash) { // pick next match + intermediate = QKeySequence(); + currentState = QKeySequence::NoMatch; // Free sequence keylock + clash++; +#ifndef QT_NO_STATUSBAR + if (mainStatusBar && + !lastitem->signal && + !(lastaccel->parent->receivers(SIGNAL(activatedAmbiguously(int))))) + mainStatusBar->showMessage(message, 2000); +#endif + lastaccel->activateAmbiguously(lastitem); + } else { // start (or wrap) with the first matching + intermediate = QKeySequence(); + currentState = QKeySequence::NoMatch; // Free sequence keylock + clash = 0; +#ifndef QT_NO_STATUSBAR + if (mainStatusBar && + !firstitem->signal && + !(firstaccel->parent->receivers(SIGNAL(activatedAmbiguously(int))))) + mainStatusBar->showMessage(message, 2000); +#endif + firstaccel->activateAmbiguously(firstitem); + } + e->accept(); + return true; +} + +Q3AccelPrivate::Q3AccelPrivate(Q3Accel* p) + : parent(p) +{ + Q3AccelManager::self()->registerAccel(this); + aitems.setAutoDelete(true); + ignorewhatsthis = false; +} + +Q3AccelPrivate::~Q3AccelPrivate() +{ + Q3AccelManager::self()->unregisterAccel(this); +} + +static Q3AccelItem *find_id(Q3AccelList &list, int id) +{ + register Q3AccelItem *item = list.first(); + while (item && item->id != id) + item = list.next(); + return item; +} + +static Q3AccelItem *find_key(Q3AccelList &list, const QKeySequence &key) +{ + register Q3AccelItem *item = list.first(); + while (item && !(item->key == key)) + item = list.next(); + return item; +} + +/*! + Constructs a Q3Accel object called \a name, with parent \a parent. + The accelerator operates on \a parent. +*/ + +Q3Accel::Q3Accel(QWidget *parent, const char *name) + : QObject(parent, name) +{ + d = new Q3AccelPrivate(this); + d->enabled = true; + d->watch = parent; +#if defined(QT_CHECK_NULL) + if (!d->watch) + qWarning("Q3Accel: An accelerator must have a parent or a watch widget"); +#endif +} + +/*! + Constructs a Q3Accel object called \a name, that operates on \a + watch, and is a child of \a parent. + + This constructor is not needed for normal application programming. +*/ +Q3Accel::Q3Accel(QWidget* watch, QObject *parent, const char *name) + : QObject(parent, name) +{ + d = new Q3AccelPrivate(this); + d->enabled = true; + d->watch = watch; +#if defined(QT_CHECK_NULL) + if (!d->watch) + qWarning("Q3Accel: An accelerator must have a parent or a watch widget"); +#endif +} + +/*! + Destroys the accelerator object and frees all allocated resources. +*/ + +Q3Accel::~Q3Accel() +{ + delete d; +} + + +/*! + \fn void Q3Accel::activated(int id) + + This signal is emitted when the user types the shortcut's key + sequence. \a id is a number that identifies this particular + accelerator item. + + \sa activatedAmbiguously() +*/ + +/*! + \fn void Q3Accel::activatedAmbiguously(int id) + + This signal is emitted when the user types a shortcut key + sequence that is ambiguous. For example, if one key sequence is a + "prefix" for another and the user types these keys it isn't clear + if they want the shorter key sequence, or if they're about to + type more to complete the longer key sequence. \a id is a number + that identifies this particular accelerator item. + + \sa activated() +*/ + +/*! + Returns true if the accelerator is enabled; otherwise returns + false. + + \sa setEnabled(), isItemEnabled() +*/ + +bool Q3Accel::isEnabled() const +{ + return d->enabled; +} + + +/*! + Enables the accelerator if \a enable is true, or disables it if \a + enable is false. + + Individual keys can also be enabled or disabled using + setItemEnabled(). To work, a key must be an enabled item in an + enabled Q3Accel. + + \sa isEnabled(), setItemEnabled() +*/ + +void Q3Accel::setEnabled(bool enable) +{ + d->enabled = enable; +} + + +/*! + Returns the number of accelerator items in this accelerator. +*/ + +uint Q3Accel::count() const +{ + return d->aitems.count(); +} + + +static int get_seq_id() +{ + static int seq_no = -2; // -1 is used as return value in findKey() + return seq_no--; +} + +/*! + Inserts an accelerator item and returns the item's identifier. + + \a key is a key code and an optional combination of SHIFT, CTRL + and ALT. \a id is the accelerator item id. + + If \a id is negative, then the item will be assigned a unique + negative identifier less than -1. + + \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 3 +*/ + +int Q3Accel::insertItem(const QKeySequence& key, int id) +{ + if (id == -1) + id = get_seq_id(); + d->aitems.insert(0, new Q3AccelItem(key,id)); + return id; +} + +/*! + Removes the accelerator item with the identifier \a id. +*/ + +void Q3Accel::removeItem(int id) +{ + if (find_id(d->aitems, id)) + d->aitems.remove(); +} + + +/*! + Removes all accelerator items. +*/ + +void Q3Accel::clear() +{ + d->aitems.clear(); +} + + +/*! + Returns the key sequence of the accelerator item with identifier + \a id, or an invalid key sequence (0) if the id cannot be found. +*/ + +QKeySequence Q3Accel::key(int id) +{ + Q3AccelItem *item = find_id(d->aitems, id); + return item ? item->key : QKeySequence(0); +} + + +/*! + Returns the identifier of the accelerator item with the key code + \a key, or -1 if the item cannot be found. +*/ + +int Q3Accel::findKey(const QKeySequence& key) const +{ + Q3AccelItem *item = find_key(d->aitems, key); + return item ? item->id : -1; +} + + +/*! + Returns true if the accelerator item with the identifier \a id is + enabled. Returns false if the item is disabled or cannot be found. + + \sa setItemEnabled(), isEnabled() +*/ + +bool Q3Accel::isItemEnabled(int id) const +{ + Q3AccelItem *item = find_id(d->aitems, id); + return item ? item->enabled : false; +} + + +/*! + Enables the accelerator item with the identifier \a id if \a + enable is true, and disables item \a id if \a enable is false. + + To work, an item must be enabled and be in an enabled Q3Accel. + + \sa isItemEnabled(), isEnabled() +*/ + +void Q3Accel::setItemEnabled(int id, bool enable) +{ + Q3AccelItem *item = find_id(d->aitems, id); + if (item) + item->enabled = enable; +} + + +/*! + Connects the accelerator item \a id to the slot \a member of \a + receiver. Returns true if the connection is successful. + + \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 4 + + Of course, you can also send a signal as \a member. + + Normally accelerators are connected to slots which then receive + the \c activated(int id) signal with the id of the accelerator + item that was activated. If you choose to connect a specific + accelerator item using this function, the \c activated() signal is + emitted if the associated key sequence is pressed but no \c + activated(int id) signal is emitted. + + \sa disconnectItem(), QObject::connect() +*/ + +bool Q3Accel::connectItem(int id, const QObject *receiver, const char *member) +{ + Q3AccelItem *item = find_id(d->aitems, id); + if (item) { + if (!item->signal) { + item->signal = new Q3Signal; + Q_CHECK_PTR(item->signal); + } + return item->signal->connect(receiver, member); + } + return false; +} + +/*! + Disconnects the accelerator item identified by \a id from + the function called \a member in the \a receiver object. + Returns true if the connection existed and the disconnect + was successful. + + \sa connectItem(), QObject::disconnect() +*/ + +bool Q3Accel::disconnectItem(int id, const QObject *receiver, + const char *member) +{ + Q3AccelItem *item = find_id(d->aitems, id); + if (item && item->signal) + return item->signal->disconnect(receiver, member); + return false; +} + +void Q3AccelPrivate::activate(Q3AccelItem* item) +{ +#ifndef QT_NO_WHATSTHIS + if (QWhatsThis::inWhatsThisMode() && !ignorewhatsthis) { + QWhatsThis::showText(QCursor::pos(), item->whatsthis); + return; + } +#endif + if (item->signal) + item->signal->activate(); + else + emit parent->activated(item->id); +} + +void Q3AccelPrivate::activateAmbiguously(Q3AccelItem* item) +{ + if (item->signal) + item->signal->activate(); + else + emit parent->activatedAmbiguously(item->id); +} + + +/*! + Returns the shortcut key sequence for \a str, or an invalid key + sequence (0) if \a str has no shortcut sequence. + + For example, shortcutKey("E&xit") returns QKeySequence(Qt::ALT + + Qt::Key_X), shortcutKey("&Quit") returns QKeySequence(Qt::ALT + + Qt::Key_Q), and shortcutKey("Quit") returns QKeySequence(). +*/ + +QKeySequence Q3Accel::shortcutKey(const QString &str) +{ + if(qt_accel_no_shortcuts) + return QKeySequence(); + + int p = 0; + while (p >= 0) { + p = str.find(QLatin1Char('&'), p) + 1; + if (p <= 0 || p >= (int)str.length()) + return 0; + if (str[p] != QLatin1Char('&')) { + QChar c = str[p]; + if (c.isPrint()) { + char ltr = c.upper().latin1(); + if (ltr >= (char)Key_A && ltr <= (char)Key_Z) + c = QLatin1Char(ltr); + else + c = c.lower(); + return QKeySequence(c.unicode() + ALT + UNICODE_ACCEL); + } + } + p++; + } + return QKeySequence(); +} + +/*! \obsolete + + Creates an accelerator string for the key \a k. + For instance CTRL+Key_O gives "Ctrl+O". The "Ctrl" etc. + are translated (using QObject::tr()) in the "Q3Accel" context. + + The function is superfluous. Cast the QKeySequence \a k to a + QString for the same effect. +*/ +QString Q3Accel::keyToString(QKeySequence k) +{ + return (QString) k; +} + +/*!\obsolete + + Returns an accelerator code for the string \a s. For example + "Ctrl+O" gives CTRL+UNICODE_ACCEL+'O'. The strings "Ctrl", + "Shift", "Alt" are recognized, as well as their translated + equivalents in the "Q3Accel" context (using QObject::tr()). Returns 0 + if \a s is not recognized. + + This function is typically used with \link QObject::tr() tr + \endlink(), so that accelerator keys can be replaced in + translations: + + \snippet doc/src/snippets/code/src_qt3support_other_q3accel.cpp 5 + + Notice the "File|Open" translator comment. It is by no means + necessary, but it provides some context for the human translator. + + The function is superfluous. Construct a QKeySequence from the + string \a s for the same effect. + + \sa QObject::tr(), {Internationalization with Qt} +*/ +QKeySequence Q3Accel::stringToKey(const QString & s) +{ + return QKeySequence(s); +} + + +/*! + Sets a What's This help text for the accelerator item \a id to \a + text. + + The text will be shown when the application is in What's This mode + and the user hits the accelerator key. + + To set What's This help on a menu item (with or without an + accelerator key), use Q3MenuData::setWhatsThis(). + + \sa whatsThis(), QWhatsThis::inWhatsThisMode(), QAction::setWhatsThis() +*/ +void Q3Accel::setWhatsThis(int id, const QString& text) +{ + Q3AccelItem *item = find_id(d->aitems, id); + if (item) + item->whatsthis = text; +} + +/*! + Returns the What's This help text for the specified item \a id or + an empty string if no text has been specified. + + \sa setWhatsThis() +*/ +QString Q3Accel::whatsThis(int id) const +{ + + Q3AccelItem *item = find_id(d->aitems, id); + return item? item->whatsthis : QString(); +} + +/*!\internal */ +void Q3Accel::setIgnoreWhatsThis(bool b) +{ + d->ignorewhatsthis = b; +} + +/*!\internal */ +bool Q3Accel::ignoreWhatsThis() const +{ + return d->ignorewhatsthis; +} + +/*! + \fn void Q3Accel::repairEventFilter() + \internal +*/ + +QT_END_NAMESPACE diff --git a/src/qt3support/other/q3accel.h b/src/qt3support/other/q3accel.h new file mode 100644 index 0000000..36adfa7 --- /dev/null +++ b/src/qt3support/other/q3accel.h @@ -0,0 +1,110 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3ACCEL_H +#define Q3ACCEL_H + +#include <QtCore/qobject.h> +#include <QtGui/qkeysequence.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3AccelPrivate; + +class Q_COMPAT_EXPORT Q3Accel : public QObject // accelerator class +{ + Q_OBJECT +public: + Q3Accel( QWidget *parent, const char *name=0 ); + Q3Accel( QWidget* watch, QObject *parent, const char *name=0 ); + ~Q3Accel(); + + bool isEnabled() const; + void setEnabled( bool ); + + uint count() const; + + int insertItem( const QKeySequence& key, int id=-1); + void removeItem( int id ); + void clear(); + + QKeySequence key( int id ); + int findKey( const QKeySequence& key ) const; + + bool isItemEnabled( int id ) const; + void setItemEnabled( int id, bool enable ); + + bool connectItem( int id, const QObject *receiver, const char* member ); + bool disconnectItem( int id, const QObject *receiver, const char* member ); + + void repairEventFilter() {} + + void setWhatsThis( int id, const QString& ); + QString whatsThis( int id ) const; + void setIgnoreWhatsThis( bool ); + bool ignoreWhatsThis() const; + + static QKeySequence shortcutKey( const QString & ); + static QString keyToString(QKeySequence k ); + static QKeySequence stringToKey( const QString & ); + +Q_SIGNALS: + void activated( int id ); + void activatedAmbiguously( int id ); + +private: + Q3AccelPrivate * d; + +private: + Q_DISABLE_COPY(Q3Accel) + friend class Q3AccelPrivate; + friend class Q3AccelManager; +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3ACCEL_H diff --git a/src/qt3support/other/q3boxlayout.cpp b/src/qt3support/other/q3boxlayout.cpp new file mode 100644 index 0000000..cc830bf --- /dev/null +++ b/src/qt3support/other/q3boxlayout.cpp @@ -0,0 +1,132 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +/*! + \class Q3HBoxLayout + \compat + + \brief The Q3HBoxLayout class lines up widgets horizontally. + \sa Q3VBoxLayout +*/ + +/*! + \fn Q3HBoxLayout::Q3HBoxLayout(QWidget *parent, int margin = 0, int spacing = -1, const char *name = 0) + + Constructs a new top-level horizontal box called \a name, with parent + \a parent. The \a margin is the number of pixels between the edge of the + widget and its managed children. The \a spacing is the default number of + pixels between neighboring children. If \a spacing is -1 the value of margin + is used for spacing. +*/ + +/*! + \fn Q3HBoxLayout::Q3HBoxLayout(QLayout *parentLayout, int spacing = -1, const char *name = 0) + + Constructs a new horizontal box called \a name and adds it to + \a parentLayout. The \a spacing is the default number of pixels between + neighboring children. If \a spacing is -1, this Q3HBoxLayout will inherit + its parent's spacing. +*/ + +/*! + \fn Q3HBoxLayout::Q3HBoxLayout(int spacing = -1, const char *name = 0) + + Constructs a new horizontal box called \a name. You must add it to another + layout. The \a spacing is the default number of pixels between neighboring + children. If \a spacing is -1, this QHBoxLayout will inherit its parent's + spacing(). +*/ + +/*! + \fn Q3HBoxLayout::Q3HBoxLayout() + \internal +*/ + +/*! + \fn Q3HBoxLayout::Q3HBoxLayout(QWidget *parent) + \internal +*/ + +/*! + \class Q3VBoxLayout + \compat + + \brief The Q3VBoxLayout class lines up widgets vertically. + \sa Q3HBoxLayout +*/ + +/*! + \fn Q3VBoxLayout::Q3VBoxLayout(QWidget *parent, int margin = 0, int spacing = -1, const char *name = 0) + + Constructs a new top-level vertical box called \a name, with parent + \a parent. The \a margin is the number of pixels between the edge of the + widget and its managed children. The \a spacing is the default number of + pixels between neighboring children. If \a spacing is -1 the value of + margin is used for spacing. +*/ + +/*! + \fn Q3VBoxLayout::Q3VBoxLayout(QLayout *parentLayout, int spacing = -1, const char *name = 0) + + Constructs a new vertical box called \a name and adds it to + \a parentLayout. The \a spacing is the default number of pixels between + neighboring children. If \a spacing is -1, this Q3VBoxLayout will inherit + its parent's spacing(). +*/ + +/*! + \fn Q3VBoxLayout::Q3VBoxLayout(int spacing = -1, const char *name = 0) + + Constructs a new vertical box called \a name. You must add it to another + layout. The \a spacing is the default number of pixels between neighboring + children. If \a spacing is -1, this Q3VBoxLayout will inherit its parent's + spacing(). +*/ + +/*! + \fn Q3VBoxLayout::Q3VBoxLayout() + \internal +*/ + +/*! + \fn Q3VBoxLayout::Q3VBoxLayout(QWidget *parent) + \internal +*/ diff --git a/src/qt3support/other/q3boxlayout.h b/src/qt3support/other/q3boxlayout.h new file mode 100644 index 0000000..f0b527a --- /dev/null +++ b/src/qt3support/other/q3boxlayout.h @@ -0,0 +1,122 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3BOXLAYOUT_H +#define Q3BOXLAYOUT_H + +#include <QtGui/qboxlayout.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3BoxLayout : public QBoxLayout +{ +public: + inline explicit Q3BoxLayout(Direction dir, QWidget *parent = 0) + : QBoxLayout(dir, parent) { setMargin(0); setSpacing(0); } + + inline Q3BoxLayout(QWidget *parent, Direction dir, int margin = 0, int spacing = -1, + const char *name = 0) + : QBoxLayout(parent, dir, margin, spacing, name) {} + + inline Q3BoxLayout(QLayout *parentLayout, Direction dir, int spacing = -1, + const char *name = 0) + : QBoxLayout(parentLayout, dir, spacing, name) { setMargin(0); } + + inline Q3BoxLayout(Direction dir, int spacing, const char *name = 0) + : QBoxLayout(dir, spacing, name) { setMargin(0); } + +private: + Q_DISABLE_COPY(Q3BoxLayout) +}; + +class Q3HBoxLayout : public Q3BoxLayout +{ +public: + inline Q3HBoxLayout() : Q3BoxLayout(LeftToRight) {} + + inline explicit Q3HBoxLayout(QWidget *parent) : Q3BoxLayout(LeftToRight, parent) {} + + inline Q3HBoxLayout(QWidget *parent, int margin, + int spacing = -1, const char *name = 0) + : Q3BoxLayout(parent, LeftToRight, margin, spacing, name) {} + + inline Q3HBoxLayout(QLayout *parentLayout, + int spacing = -1, const char *name = 0) + : Q3BoxLayout(parentLayout, LeftToRight, spacing, name) {} + + inline Q3HBoxLayout(int spacing, const char *name = 0) + : Q3BoxLayout(LeftToRight, spacing, name) {} + +private: + Q_DISABLE_COPY(Q3HBoxLayout) +}; + +class Q3VBoxLayout : public Q3BoxLayout +{ +public: + inline Q3VBoxLayout() : Q3BoxLayout(TopToBottom) {} + + inline explicit Q3VBoxLayout(QWidget *parent) : Q3BoxLayout(TopToBottom, parent) {} + + inline Q3VBoxLayout(QWidget *parent, int margin, + int spacing = -1, const char *name = 0) + : Q3BoxLayout(parent, TopToBottom, margin, spacing, name) {} + + inline Q3VBoxLayout(QLayout *parentLayout, + int spacing = -1, const char *name = 0) + : Q3BoxLayout(parentLayout, TopToBottom, spacing, name) {} + + inline Q3VBoxLayout(int spacing, const char *name = 0) + : Q3BoxLayout(TopToBottom, spacing, name) {} + +private: + Q_DISABLE_COPY(Q3VBoxLayout) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3BOXLAYOUT_H diff --git a/src/qt3support/other/q3dragobject.cpp b/src/qt3support/other/q3dragobject.cpp new file mode 100644 index 0000000..fb57220 --- /dev/null +++ b/src/qt3support/other/q3dragobject.cpp @@ -0,0 +1,1577 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qplatformdefs.h" + +#ifndef QT_NO_MIME + +#include "q3dragobject.h" +#include "qpixmap.h" +#include "qevent.h" +#include "qfile.h" +#include "qtextcodec.h" +#include "qapplication.h" +#include "qpoint.h" +#include "qwidget.h" +#include "qbuffer.h" +#include "qimagereader.h" +#include "qimagewriter.h" +#include "qimage.h" +#include "qregexp.h" +#include "qdir.h" +#include "qdrag.h" +#include "q3strlist.h" +#include "q3cstring.h" + +#include <private/qobject_p.h> + +#include <ctype.h> +#if defined(Q_OS_WINCE) +#include <winsock.h> +#include "qfunctions_wince.h" +#endif + +QT_BEGIN_NAMESPACE + +static QWidget *last_target = 0; + +class QDragMime; + +class Q3DragObjectPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(Q3DragObject) +public: + Q3DragObjectPrivate(): hot(0,0),pm_cursor(0) {} + QPixmap pixmap; + QPoint hot; + // store default cursors + QPixmap *pm_cursor; +}; + +class Q3TextDragPrivate : public Q3DragObjectPrivate +{ + Q_DECLARE_PUBLIC(Q3TextDrag) +public: + Q3TextDragPrivate() { setSubType(QLatin1String("plain")); } + void setSubType(const QString & st) { + subtype = st; + fmt = QString(QLatin1String("text/")).toLatin1() + subtype.toLatin1(); + } + + QString txt; + QString subtype; + QByteArray fmt; +}; + +class Q3StoredDragPrivate : public Q3DragObjectPrivate +{ + Q_DECLARE_PUBLIC(Q3StoredDrag) +public: + Q3StoredDragPrivate() {} + const char* fmt; + QByteArray enc; +}; + +class Q3ImageDragPrivate : public Q3DragObjectPrivate +{ + Q_DECLARE_PUBLIC(Q3ImageDrag) +public: + QImage img; + QList<QByteArray> ofmts; +}; + +class QDragMime : public QMimeData +{ +public: + QDragMime(Q3DragObject *parent) : QMimeData(), dragObject(parent) { } + ~QDragMime(); + + QByteArray data(const QString &mimetype) const; + bool hasFormat(const QString &mimetype) const; + QStringList formats() const; + + QPointer<Q3DragObject> dragObject; +}; + +QDragMime::~QDragMime() +{ + delete dragObject; +} +QByteArray QDragMime::data(const QString &mimetype) const +{ + return dragObject->encodedData(mimetype.latin1()); +} + +bool QDragMime::hasFormat(const QString &mimetype) const +{ + return dragObject->provides(mimetype.latin1()); +} + +QStringList QDragMime::formats() const +{ + int i = 0; + const char *format; + QStringList f; + while ((format = dragObject->format(i))) { + f.append(QLatin1String(format)); + ++i; + } + return f; +} + +/*! + Constructs a drag object called \a name with a parent \a + dragSource. + + Note that the drag object will be deleted when the \a dragSource is + deleted. +*/ + +Q3DragObject::Q3DragObject(QWidget * dragSource, const char * name) + : QObject(*(new Q3DragObjectPrivate), dragSource) +{ + setObjectName(QLatin1String(name)); +} + +/*! \internal */ +Q3DragObject::Q3DragObject(Q3DragObjectPrivate &dd, QWidget *dragSource) + : QObject(dd, dragSource) +{ +} + +/*! + Destroys the drag object, canceling any drag and drop operation in + which it is involved. +*/ + +Q3DragObject::~Q3DragObject() +{ +} + +#ifndef QT_NO_DRAGANDDROP +/*! + Set the pixmap, \a pm, to display while dragging the object. The + platform-specific implementation will use this where it can - so + provide a small masked pixmap, and do not assume that the user + will actually see it. For example, cursors on Windows 95 are of + limited size. + + The \a hotspot is the point on (or off) the pixmap that should be + under the cursor as it is dragged. It is relative to the top-left + pixel of the pixmap. + + \warning We have seen problems with drag cursors on different + graphics hardware and driver software on Windows. Setting the + graphics acceleration in the display settings down one tick solved + the problems in all cases. +*/ +void Q3DragObject::setPixmap(QPixmap pm, const QPoint& hotspot) +{ + Q_D(Q3DragObject); + d->pixmap = pm; + d->hot = hotspot; +#if 0 + QDragManager *manager = QDragManager::self(); + if (manager && manager->object == d->data) + manager->updatePixmap(); +#endif +} + +/*! + \overload + + Uses a hotspot that positions the pixmap below and to the right of + the mouse pointer. This allows the user to clearly see the point + on the window where they are dragging the data. +*/ +void Q3DragObject::setPixmap(QPixmap pm) +{ + setPixmap(pm,QPoint(-10, -10)); +} + +/*! + Returns the currently set pixmap, or a null pixmap if none is set. + + \sa QPixmap::isNull() +*/ +QPixmap Q3DragObject::pixmap() const +{ + return d_func()->pixmap; +} + +/*! + Returns the currently set pixmap hotspot. + + \sa setPixmap() +*/ +QPoint Q3DragObject::pixmapHotSpot() const +{ + return d_func()->hot; +} + +/*! + Starts a drag operation using the contents of this object, using + DragDefault mode. + + The function returns true if the caller should delete the original + copy of the dragged data (but see target()); otherwise returns + false. + + If the drag contains \e references to information (e.g. file names + in a Q3UriDrag are references) then the return value should always + be ignored, as the target is expected to directly manipulate the + content referred to by the drag object. On X11 the return value should + always be correct anyway, but on Windows this is not necessarily + the case; e.g. the file manager starts a background process to + move files, so the source \e{must not} delete the files! + + Note that on Windows the drag operation will start a blocking modal + event loop that will not dispatch any QTimers. +*/ +bool Q3DragObject::drag() +{ + return drag(DragDefault); +} + +/*! + After the drag completes, this function will return the QWidget + which received the drop, or 0 if the data was dropped on another + application. + + This can be useful for detecting the case where drag and drop is + to and from the same widget. +*/ +QWidget *Q3DragObject::target() +{ + return last_target; +} + +/*! + Starts a drag operation using the contents of this object, using + \c DragMove mode. Be sure to read the constraints described in + drag(). + + Returns true if the data was dragged as a \e move, indicating that + the caller should remove the original source of the data (the drag + object must continue to have a copy); otherwise returns false. + + \sa drag() dragCopy() dragLink() +*/ +bool Q3DragObject::dragMove() +{ + return drag(DragMove); +} + + +/*! + Starts a drag operation using the contents of this object, using + \c DragCopy mode. Be sure to read the constraints described in + drag(). + + \sa drag() dragMove() dragLink() +*/ +void Q3DragObject::dragCopy() +{ + (void)drag(DragCopy); +} + +/*! + Starts a drag operation using the contents of this object, using + \c DragLink mode. Be sure to read the constraints described in + drag(). + + \sa drag() dragCopy() dragMove() +*/ +void Q3DragObject::dragLink() +{ + (void)drag(DragLink); +} + + +/*! + \enum Q3DragObject::DragMode + + This enum describes the possible drag modes. + + \value DragDefault The mode is determined heuristically. + \value DragCopy The data is copied. + \value DragMove The data is moved. + \value DragLink The data is linked. + \value DragCopyOrMove The user chooses the mode by using the + \key{Shift} key to switch from the default + copy mode to move mode. +*/ + + +/*! + \overload + Starts a drag operation using the contents of this object. + + At this point, the object becomes owned by Qt, not the + application. You should not delete the drag object or anything it + references. The actual transfer of data to the target application + will be done during future event processing - after that time the + drag object will be deleted. + + Returns true if the dragged data was dragged as a \e move, + indicating that the caller should remove the original source of + the data (the drag object must continue to have a copy); otherwise + returns false. + + The \a mode specifies the drag mode (see + \l{Q3DragObject::DragMode}.) Normally one of the simpler drag(), + dragMove(), or dragCopy() functions would be used instead. +*/ +bool Q3DragObject::drag(DragMode mode) +{ + Q_D(Q3DragObject); + QDragMime *data = new QDragMime(this); + int i = 0; + const char *fmt; + while ((fmt = format(i))) { + data->setData(QLatin1String(fmt), encodedData(fmt)); + ++i; + } + + QDrag *drag = new QDrag(qobject_cast<QWidget *>(parent())); + drag->setMimeData(data); + drag->setPixmap(d->pixmap); + drag->setHotSpot(d->hot); + + Qt::DropActions allowedOps; + Qt::DropAction defaultOp = Qt::IgnoreAction; + switch(mode) { + default: + case DragDefault: + case DragCopyOrMove: + allowedOps = Qt::CopyAction|Qt::MoveAction; + defaultOp = Qt::IgnoreAction; + break; + case DragCopy: + allowedOps = Qt::CopyAction; + defaultOp = Qt::CopyAction; + break; + case DragMove: + allowedOps = Qt::MoveAction; + defaultOp = Qt::MoveAction; + break; + case DragLink: + allowedOps = Qt::LinkAction; + defaultOp = Qt::LinkAction; + break; + } + bool retval = (drag->exec(allowedOps, defaultOp) == Qt::MoveAction); + last_target = drag->target(); + + return retval; +} + +#endif + + +/*! + Returns a pointer to the widget where this object originated (the drag + source). +*/ + +QWidget * Q3DragObject::source() +{ + if (parent() && parent()->isWidgetType()) + return (QWidget *)parent(); + else + return 0; +} + + +/*! + \class Q3DragObject + + \brief The Q3DragObject class encapsulates MIME-based data + transfer. + + \compat + + Q3DragObject is the base class for all data that needs to be + transferred between and within applications, both for drag and + drop and for the clipboard. + + See the \link dnd.html Drag and drop documentation\endlink for an + overview of how to provide drag and drop in your application. + + See the QClipboard documentation for an overview of how to provide + cut and paste in your application. + + The drag() function is used to start a drag operation. You can + specify the \l DragMode in the call or use one of the convenience + functions dragCopy(), dragMove(), or dragLink(). The drag source + where the data originated is retrieved with source(). If the data + was dropped on a widget within the application, target() will + return a pointer to that widget. Specify the pixmap to display + during the drag with setPixmap(). +*/ + +static +void stripws(QByteArray& s) +{ + int f; + while ((f = s.indexOf(' ')) >= 0) + s.remove(f,1); +} + +/*! + \class Q3TextDrag + + \brief The Q3TextDrag class is a drag and drop object for + transferring plain and Unicode text. + + \compat + + Plain text is passed in a QString which may contain multiple lines + (i.e. may contain newline characters). The drag target will receive + the newlines according to the runtime environment, e.g. LF on Unix, + and CRLF on Windows. + + Qt provides no built-in mechanism for delivering only a single-line. + + For more information about drag and drop, see the Q3DragObject class + and the \link dnd.html drag and drop documentation\endlink. +*/ + + +/*! + Constructs a text drag object with the given \a name, and sets its data + to \a text. The \a dragSource is the widget that the drag operation started + from. +*/ + +Q3TextDrag::Q3TextDrag(const QString &text, QWidget * dragSource, const char * name) + : Q3DragObject(*new Q3TextDragPrivate, dragSource) +{ + setObjectName(QLatin1String(name)); + setText(text); +} + + +/*! + Constructs a default text drag object with the given \a name. + The \a dragSource is the widget that the drag operation started from. +*/ + +Q3TextDrag::Q3TextDrag(QWidget * dragSource, const char * name) + : Q3DragObject(*(new Q3TextDragPrivate), dragSource) +{ + setObjectName(QLatin1String(name)); +} + +/*! \internal */ +Q3TextDrag::Q3TextDrag(Q3TextDragPrivate &dd, QWidget *dragSource) + : Q3DragObject(dd, dragSource) +{ + +} + +/*! + Destroys the text drag object. +*/ +Q3TextDrag::~Q3TextDrag() +{ + +} + +/*! + \fn void Q3TextDrag::setSubtype(const QString &subtype) + + Sets the MIME \a subtype of the text being dragged. The default subtype + is "plain", so the default MIME type of the text is "text/plain". + You might use this to declare that the text is "text/html" by calling + setSubtype("html"). +*/ +void Q3TextDrag::setSubtype(const QString & st) +{ + d_func()->setSubType(st); +} + +/*! + Sets the \a text to be dragged. You will need to call this if you did + not pass the text during construction. +*/ +void Q3TextDrag::setText(const QString &text) +{ + d_func()->txt = text; +} + + +/*! + \reimp +*/ +const char * Q3TextDrag::format(int i) const +{ + if (i > 0) + return 0; + return d_func()->fmt.constData(); +} + +QTextCodec* qt_findcharset(const QByteArray& mimetype) +{ + int i=mimetype.indexOf("charset="); + if (i >= 0) { + QByteArray cs = mimetype.mid(i+8); + stripws(cs); + i = cs.indexOf(';'); + if (i >= 0) + cs = cs.left(i); + // win98 often has charset=utf16, and we need to get the correct codec for + // it to be able to get Unicode text drops. + if (cs == "utf16") + cs = "ISO-10646-UCS-2"; + // May return 0 if unknown charset + return QTextCodec::codecForName(cs); + } + // no charset=, use locale + return QTextCodec::codecForName("utf-8"); +} + +static QTextCodec *codecForHTML(const QByteArray &ba) +{ + // determine charset + int mib = 0; + int pos; + QTextCodec *c = 0; + + if (ba.size() > 1 && (((uchar)ba[0] == 0xfe && (uchar)ba[1] == 0xff) + || ((uchar)ba[0] == 0xff && (uchar)ba[1] == 0xfe))) { + mib = 1015; // utf16 + } else if (ba.size() > 2 + && (uchar)ba[0] == 0xef + && (uchar)ba[1] == 0xbb + && (uchar)ba[2] == 0xbf) { + mib = 106; // utf-8 + } else { + pos = 0; + while ((pos = ba.indexOf('<', pos)) != -1) { + int end = ba.indexOf('>', pos+1); + if (end == -1) + break; + const QString str(QString::fromLatin1(ba.mid(pos, end-pos))); + if (str.contains(QLatin1String("meta http-equiv="), Qt::CaseInsensitive)) { + pos = str.indexOf(QLatin1String("charset="), 0, Qt::CaseInsensitive) + int(strlen("charset=")); + if (pos != -1) { + int pos2 = ba.indexOf('\"', pos+1); + QByteArray cs = ba.mid(pos, pos2-pos); + c = QTextCodec::codecForName(cs); + if (c) + return c; + } + } + pos = end; + } + } + if (mib) + c = QTextCodec::codecForMib(mib); + + return c; +} + +static +QTextCodec* findcodec(const QMimeSource* e) +{ + QTextCodec* r = 0; + const char* f; + int i; + for (i=0; (f=e->format(i)); i++) { + bool html = !qstrnicmp(f, "text/html", 9); + if (html) + r = codecForHTML(e->encodedData(f)); + if (!r) + r = qt_findcharset(QByteArray(f).toLower()); + if (r) + return r; + } + return 0; +} + + + +/*! + \reimp +*/ +QByteArray Q3TextDrag::encodedData(const char* mime) const +{ + Q_D(const Q3TextDrag); + if (mime != d->fmt) + return QByteArray(); + return d->txt.toUtf8(); +} + +/*! + \fn bool Q3TextDrag::canDecode(const QMimeSource *source) + + Returns true if the information in the MIME \a source can be decoded + into a QString; otherwise returns false. + + \sa decode() +*/ +bool Q3TextDrag::canDecode(const QMimeSource* e) +{ + const char* f; + for (int i=0; (f=e->format(i)); i++) { + if (0==qstrnicmp(f,"text/",5)) { + return findcodec(e) != 0; + } + } + return false; +} + +/*! + \fn bool Q3TextDrag::decode(const QMimeSource *source, QString &string, QString &subtype) + + \overload + + Attempts to decode the dropped information in the MIME \a source into + the \a string given. + Returns true if successful; otherwise returns false. If \a subtype + is null, any text subtype is accepted; otherwise only the + specified \a subtype is accepted. + + \sa canDecode() +*/ +bool Q3TextDrag::decode(const QMimeSource* e, QString& str, QString& subtype) +{ + if(!e) + return false; + + const char* mime; + for (int i=0; (mime = e->format(i)); i++) { + if (0==qstrnicmp(mime,"text/",5)) { + QByteArray m(mime); + m = m.toLower(); + int semi = m.indexOf(';'); + if (semi < 0) + semi = m.length(); + QString foundst(QString::fromLatin1(m.mid(5,semi-5))); + if (subtype.isNull() || foundst == subtype) { + bool html = !qstrnicmp(mime, "text/html", 9); + QTextCodec* codec = 0; + if (html) + // search for the charset tag in the HTML + codec = codecForHTML(e->encodedData(mime)); + if (!codec) + codec = qt_findcharset(m); + if (codec) { + QByteArray payload; + + payload = e->encodedData(mime); + if (payload.size()) { + int l; + if (codec->mibEnum() != 1015) { + // length is at NUL or payload.size() + l = 0; + while (l < (int)payload.size() && payload[l]) + l++; + } else { + l = payload.size(); + } + + str = codec->toUnicode(payload,l); + + if (subtype.isNull()) + subtype = foundst; + + return true; + } + } + } + } + } + return false; +} + +/*! + \fn bool Q3TextDrag::decode(const QMimeSource *source, QString &string) + + Attempts to decode the dropped information in the MIME \a source into + the \a string given. + Returns true if successful; otherwise returns false. + + \sa canDecode() +*/ +bool Q3TextDrag::decode(const QMimeSource* e, QString& str) +{ + QString st; + return decode(e, str, st); +} + + +/* + Q3ImageDrag could use an internal MIME type for communicating QPixmaps + and QImages rather than always converting to raw data. This is available + for that purpose and others. It is not currently used. +*/ + +/*! + \class Q3ImageDrag + + \brief The Q3ImageDrag class provides a drag and drop object for + transferring images. + + \compat + + Images are offered to the receiving application in multiple + formats, determined by Qt's output formats. +*/ + +/*! + Constructs an image drag object with the given \a name, and sets its + data to \a image. The \a dragSource is the widget that the drag operation + started from. +*/ + +Q3ImageDrag::Q3ImageDrag(QImage image, + QWidget * dragSource, const char * name) + : Q3DragObject(*(new Q3ImageDragPrivate), dragSource) +{ + setObjectName(QLatin1String(name)); + setImage(image); +} + +/*! + Constructs a default image drag object with the given \a name. + The \a dragSource is the widget that the drag operation started from. +*/ + +Q3ImageDrag::Q3ImageDrag(QWidget * dragSource, const char * name) + : Q3DragObject(*(new Q3ImageDragPrivate), dragSource) +{ + setObjectName(QLatin1String(name)); +} + +/*! \internal */ +Q3ImageDrag::Q3ImageDrag(Q3ImageDragPrivate &dd, QWidget *dragSource) + : Q3DragObject(dd, dragSource) +{ +} + +/*! + Destroys the image drag object. +*/ + +Q3ImageDrag::~Q3ImageDrag() +{ + // nothing +} + + +/*! + Sets the \a image to be dragged. You will need to call this if you did + not pass the image during construction. +*/ +void Q3ImageDrag::setImage(QImage image) +{ + Q_D(Q3ImageDrag); + d->img = image; + QList<QByteArray> formats = QImageWriter::supportedImageFormats(); + formats.removeAll("PBM"); // remove non-raw PPM + if (image.depth()!=32) { + // BMP better than PPM for paletted images + if (formats.removeAll("BMP")) // move to front + formats.insert(0,"BMP"); + } + // PNG is best of all + if (formats.removeAll("PNG")) // move to front + formats.insert(0,"PNG"); + + for(int i = 0; i < formats.count(); i++) { + QByteArray format("image/"); + format += formats.at(i); + format = format.toLower(); + if (format == "image/pbmraw") + format = "image/ppm"; + d->ofmts.append(format); + } + d->ofmts.append("application/x-qt-image"); +} + +/*! + \reimp +*/ +const char * Q3ImageDrag::format(int i) const +{ + Q_D(const Q3ImageDrag); + return i < d->ofmts.count() ? d->ofmts.at(i).data() : 0; +} + +/*! + \reimp +*/ +QByteArray Q3ImageDrag::encodedData(const char* fmt) const +{ + Q_D(const Q3ImageDrag); + QString imgFormat(fmt); + if (imgFormat == QLatin1String("application/x-qt-image")) + imgFormat = QLatin1String("image/PNG"); + + if (imgFormat.startsWith("image/")){ + QByteArray f(imgFormat.mid(6).toAscii()); + QByteArray dat; + QBuffer w(&dat); + w.open(QIODevice::WriteOnly); + QImageWriter writer(&w, f.toUpper()); + if (!writer.write(d->img)) + return QByteArray(); + w.close(); + return dat; + } else { + return QByteArray(); + } +} + +/*! + \fn bool Q3ImageDrag::canDecode(const QMimeSource *source) + + Returns true if the information in the MIME \a source can be decoded + into an image; otherwise returns false. + + \sa decode() +*/ +bool Q3ImageDrag::canDecode(const QMimeSource* e) +{ + return e->provides("application/x-qt-image"); +} + +/*! + \fn bool Q3ImageDrag::decode(const QMimeSource *source, QImage &image) + + Decode the dropped information in the MIME \a source into the \a image. + Returns true if successful; otherwise returns false. + + \sa canDecode() +*/ +bool Q3ImageDrag::decode(const QMimeSource* e, QImage& img) +{ + if (!e) + return false; + + QByteArray payload = e->encodedData("application/x-qt-image"); + if (payload.isEmpty()) + return false; + + img.loadFromData(payload); + if (img.isNull()) + return false; + + return true; +} + +/*! + \fn bool Q3ImageDrag::decode(const QMimeSource *source, QPixmap &pixmap) + + \overload + + Decodes the dropped information in the MIME \a source into the \a pixmap. + Returns true if successful; otherwise returns false. + + This is a convenience function that converts the information to a QPixmap + via a QImage. + + \sa canDecode() +*/ +bool Q3ImageDrag::decode(const QMimeSource* e, QPixmap& pm) +{ + if (!e) + return false; + + QImage img; + // We avoid dither, since the image probably came from this display + if (decode(e, img)) { + pm = QPixmap::fromImage(img, Qt::AvoidDither); + if (pm.isNull()) + return false; + + return true; + } + return false; +} + + + + +/*! + \class Q3StoredDrag + \brief The Q3StoredDrag class provides a simple stored-value drag object for arbitrary MIME data. + + \compat + + When a block of data has only one representation, you can use a + Q3StoredDrag to hold it. + + For more information about drag and drop, see the Q3DragObject + class and the \link dnd.html drag and drop documentation\endlink. +*/ + +/*! + Constructs a Q3StoredDrag. The \a dragSource and \a name are passed + to the Q3DragObject constructor, and the format is set to \a + mimeType. + + The data will be unset. Use setEncodedData() to set it. +*/ +Q3StoredDrag::Q3StoredDrag(const char* mimeType, QWidget * dragSource, const char * name) : + Q3DragObject(*new Q3StoredDragPrivate, dragSource) +{ + Q_D(Q3StoredDrag); + setObjectName(QLatin1String(name)); + d->fmt = qstrdup(mimeType); +} + +/*! \internal */ +Q3StoredDrag::Q3StoredDrag(Q3StoredDragPrivate &dd, const char* mimeType, QWidget * dragSource) + : Q3DragObject(dd, dragSource) +{ + d_func()->fmt = qstrdup(mimeType); +} + +/*! + Destroys the drag object. +*/ +Q3StoredDrag::~Q3StoredDrag() +{ + delete [] (char*)d_func()->fmt; +} + +/*! + \reimp +*/ +const char * Q3StoredDrag::format(int i) const +{ + if (i==0) + return d_func()->fmt; + else + return 0; +} + + +/*! + \fn void Q3StoredDrag::setEncodedData(const QByteArray &data) + + Sets the encoded \a data of this drag object. The encoded data is + delivered to drop sites; it must be in a strictly defined and portable + format. + + The drag object can't be dropped (by the user) until this function + has been called. +*/ + +void Q3StoredDrag::setEncodedData(const QByteArray & encodedData) +{ + d_func()->enc = encodedData; +} + +/*! + \fn QByteArray Q3StoredDrag::encodedData(const char *format) const + + Returns the stored data in the \a format given. + + \sa setEncodedData() +*/ +QByteArray Q3StoredDrag::encodedData(const char* m) const +{ + if (!qstricmp(m, d_func()->fmt)) + return d_func()->enc; + else + return QByteArray(); +} + + +/*! + \class Q3UriDrag + \brief The Q3UriDrag class provides a drag object for a list of URI references. + + \compat + + URIs are a useful way to refer to files that may be distributed + across multiple machines. A URI will often refer to a file on a + machine local to both the drag source and the drop target, so the + URI can be equivalent to passing a file name but is more + extensible. + + Use URIs in Unicode form so that the user can comfortably edit and + view them. For use in HTTP or other protocols, use the correctly + escaped ASCII form. + + You can convert a list of file names to file URIs using + setFileNames(), or into human-readable form with setUnicodeUris(). + + Static functions are provided to convert between filenames and + URIs; e.g. uriToLocalFile() and localFileToUri(). Static functions + are also provided to convert URIs to and from human-readable form; + e.g. uriToUnicodeUri() and unicodeUriToUri(). + You can also decode URIs from a MIME source into a list with + decodeLocalFiles() and decodeToUnicodeUris(). +*/ + +/*! + Constructs an object to drag the list of \a uris. + The \a dragSource and \a name are passed to the Q3StoredDrag constructor. + + Note that URIs are always in escaped UTF8 encoding. +*/ +Q3UriDrag::Q3UriDrag(const Q3StrList &uris, QWidget * dragSource, const char * name) : + Q3StoredDrag("text/uri-list", dragSource) +{ + setObjectName(QLatin1String(name)); + setUris(uris); +} + +/*! + Constructs an object to drag with the given \a name. + You must call setUris() before you start the drag(). + Both the \a dragSource and the \a name are passed to the Q3StoredDrag + constructor. +*/ +Q3UriDrag::Q3UriDrag(QWidget * dragSource, const char * name) : + Q3StoredDrag("text/uri-list", dragSource) +{ + setObjectName(QLatin1String(name)); +} +#endif + +/*! + Destroys the URI drag object. +*/ +Q3UriDrag::~Q3UriDrag() +{ +} + +/*! + \fn void Q3UriDrag::setUris(const QList<QByteArray> &list) + + Changes the \a list of URIs to be dragged. + + Note that URIs are always in escaped UTF8 encoding. +*/ +void Q3UriDrag::setUris(const QList<QByteArray> &uris) +{ + QByteArray a; + int c = 0; + int i; + int count = uris.count(); + for (i = 0; i < count; ++i) + c += uris.at(i).size() + 2; //length + \r\n + a.reserve(c+1); + for (i = 0; i < count; ++i) { + a.append(uris.at(i)); + a.append("\r\n"); + } + a[c] = 0; + setEncodedData(a); +} + + +/*! + \fn bool Q3UriDrag::canDecode(const QMimeSource *source) + + Returns true if decode() can decode the MIME \a source; otherwise + returns false. +*/ +bool Q3UriDrag::canDecode(const QMimeSource* e) +{ + return e->provides("text/uri-list"); +} + +/*! + \fn bool Q3UriDrag::decode(const QMimeSource* source, Q3StrList& list) + + Decodes URIs from the MIME \a source, placing the result in the \a list. + The list is cleared before any items are inserted. + + Returns true if the MIME \a source contained a valid list of URIs; + otherwise returns false. +*/ +bool Q3UriDrag::decode(const QMimeSource* e, Q3StrList& l) +{ + QByteArray payload = e->encodedData("text/uri-list"); + if (payload.size()) { + l.clear(); + l.setAutoDelete(true); + uint c=0; + const char* data = payload.data(); + while ((int)c < payload.size() && data[c]) { + uint f = c; + // Find line end + while ((int)c < payload.size() && data[c] && data[c]!='\r' + && data[c] != '\n') + c++; + Q3CString s(data+f,c-f+1); + if (s[0] != '#') // non-comment? + l.append(s); + // Skip junk + while ((int)c < payload.size() && data[c] && + (data[c]=='\n' || data[c]=='\r')) + c++; + } + return true; + } + return false; +} + +static uint htod(int h) +{ + if (isdigit(h)) + return h - '0'; + return tolower(h) - 'a' + 10; +} + +/*! + \fn Q3UriDrag::setFilenames(const QStringList &list) + + \obsolete + + Sets the filename's in the drag object to those in the given \a + list. + + Use setFileNames() instead. +*/ + +/*! + \fn void Q3UriDrag::setFileNames(const QStringList &filenames) + + Sets the URIs to be local file URIs equivalent to the \a filenames. + + \sa localFileToUri(), setUris() +*/ +void Q3UriDrag::setFileNames(const QStringList & fnames) +{ + QList<QByteArray> uris; + for (QStringList::ConstIterator i = fnames.begin(); + i != fnames.end(); ++i) { + QByteArray fileUri = localFileToUri(*i); + if (!fileUri.isEmpty()) + uris.append(fileUri); + } + + setUris(uris); +} + +/*! + \fn void Q3UriDrag::setFileNames(const QString &name) + \fn void Q3UriDrag::setFilenames(const QString &name) + + Same as setFileNames(QStringList(\a name)). +*/ + +/*! + \fn void Q3UriDrag::setUnicodeUris(const QStringList &list) + + Sets the URIs in the \a list to be Unicode URIs (only useful for + displaying to humans). + + \sa localFileToUri(), setUris() +*/ +void Q3UriDrag::setUnicodeUris(const QStringList & uuris) +{ + QList<QByteArray> uris; + for (int i = 0; i < uuris.count(); ++i) + uris.append(unicodeUriToUri(uuris.at(i))); + setUris(uris); +} + +/*! + \fn QByteArray Q3UriDrag::unicodeUriToUri(const QString &string) + + Returns the URI equivalent of the Unicode URI given in the \a string + (only useful for displaying to humans). + + \sa uriToLocalFile() +*/ +QByteArray Q3UriDrag::unicodeUriToUri(const QString& uuri) +{ + QByteArray utf8 = uuri.toUtf8(); + QByteArray escutf8; + int n = utf8.length(); + bool isFile = uuri.startsWith(QLatin1String("file://")); + for (int i=0; i<n; i++) { + if ((utf8[i] >= 'a' && utf8[i] <= 'z') + || utf8[i] == '/' + || (utf8[i] >= '0' && utf8[i] <= '9') + || (utf8[i] >= 'A' && utf8[i] <= 'Z') + + || utf8[i] == '-' || utf8[i] == '_' + || utf8[i] == '.' || utf8[i] == '!' + || utf8[i] == '~' || utf8[i] == '*' + || utf8[i] == '(' || utf8[i] == ')' + || utf8[i] == '\'' + + // Allow this through, so that all URI-references work. + || (!isFile && utf8[i] == '#') + + || utf8[i] == ';' + || utf8[i] == '?' || utf8[i] == ':' + || utf8[i] == '@' || utf8[i] == '&' + || utf8[i] == '=' || utf8[i] == '+' + || utf8[i] == '$' || utf8[i] == ',') + { + escutf8 += utf8[i]; + } else { + // Everything else is escaped as %HH + QString s; + s.sprintf("%%%02x",(uchar)utf8[i]); + escutf8 += s.latin1(); + } + } + return escutf8; +} + +/*! + Returns the URI equivalent to the absolute local \a filename. + + \sa uriToLocalFile() +*/ +QByteArray Q3UriDrag::localFileToUri(const QString& filename) +{ + QString r = filename; + + //check that it is an absolute file + if (QDir::isRelativePath(r)) + return QByteArray(); +#ifdef Q_WS_WIN + + + bool hasHost = false; + // convert form network path + if (r.left(2) == QLatin1String("\\\\") || r.left(2) == QLatin1String("//")) { + r.remove(0, 2); + hasHost = true; + } + + // Slosh -> Slash + int slosh; + while ((slosh=r.indexOf(QLatin1Char('\\'))) >= 0) { + r[slosh] = QLatin1Char('/'); + } + + // Drive + if (r[0] != QLatin1Char('/') && !hasHost) + r.insert(0,QLatin1Char('/')); + +#endif +#if defined (Q_WS_X11) && 0 + // URL without the hostname is considered to be errorneous by XDnD. + // See: http://www.newplanetsoftware.com/xdnd/dragging_files.html + // This feature is not active because this would break dnd between old and new qt apps. + char hostname[257]; + if (gethostname(hostname, 255) == 0) { + hostname[256] = '\0'; + r.prepend(QString::fromLatin1(hostname)); + } +#endif + return unicodeUriToUri(QString(QLatin1String("file://") + r)); +} + +/*! + \fn QString Q3UriDrag::uriToUnicodeUri(const char *string) + + Returns the Unicode URI (only useful for displaying to humans) + equivalent of the URI given in the \a string. + + Note that URIs are always in escaped UTF8 encoding. + + \sa localFileToUri() +*/ +QString Q3UriDrag::uriToUnicodeUri(const char* uri) +{ + QByteArray utf8; + + while (*uri) { + switch (*uri) { + case '%': { + uint ch = (uchar) uri[1]; + if (ch && uri[2]) { + ch = htod(ch) * 16 + htod((uchar) uri[2]); + utf8 += (char) ch; + uri += 2; + } + } + break; + default: + utf8 += *uri; + } + ++uri; + } + + return QString::fromUtf8(utf8); +} + +/*! + \fn QString Q3UriDrag::uriToLocalFile(const char *string) + + Returns the name of a local file equivalent to the URI given in the + \a string, or an empty string if it does not refer to a local file. + + Note that URIs are always in escaped UTF8 encoding. + + \sa localFileToUri() +*/ +QString Q3UriDrag::uriToLocalFile(const char* uri) +{ + QString file; + + if (!uri) + return file; + if (0==qstrnicmp(uri,"file:/",6)) // It is a local file uri + uri += 6; + else if (QString(QLatin1String(uri)).indexOf(QLatin1String(":/")) != -1) // It is a different scheme uri + return file; + + bool local = uri[0] != '/' || (uri[0] != '\0' && uri[1] == '/'); +#ifdef Q_WS_X11 + // do we have a hostname? + if (!local && uri[0] == '/' && uri[2] != '/') { + // then move the pointer to after the 'hostname/' part of the uri + const char* hostname_end = strchr(uri+1, '/'); + if (hostname_end != NULL) { + char hostname[257]; + if (gethostname(hostname, 255) == 0) { + hostname[256] = '\0'; + if (qstrncmp(uri+1, hostname, hostname_end - (uri+1)) == 0) { + uri = hostname_end + 1; // point after the slash + local = true; + } + } + } + } +#endif + if (local) { + file = uriToUnicodeUri(uri); + if (uri[1] == '/') { + file.remove((uint)0,1); + } else { + file.insert(0, QLatin1Char('/')); + } +#ifdef Q_WS_WIN + if (file.length() > 2 && file[0] == QLatin1Char('/') && file[2] == QLatin1Char('|')) { + file[2] = QLatin1Char(':'); + file.remove(0,1); + } else if (file.length() > 2 && file[0] == QLatin1Char('/') && file[1].isLetter() && file[2] == QLatin1Char(':')) { + file.remove(0, 1); + } + // Leave slash as slashes. +#endif + } +#ifdef Q_WS_WIN + else { + file = uriToUnicodeUri(uri); + // convert to network path + file.insert(1, QLatin1Char('/')); // leave as forward slashes + } +#endif + + return file; +} + +/*! + \fn bool Q3UriDrag::decodeLocalFiles(const QMimeSource *source, QStringList &list) + + Decodes URIs from the MIME \a source, converting them to local filenames + where possible, and places them in the \a list (which is first cleared). + + Returns true if the MIME \a source contained a valid list of URIs; + otherwise returns false. The list will be empty if no URIs referred to + local files. +*/ +bool Q3UriDrag::decodeLocalFiles(const QMimeSource* e, QStringList& l) +{ + Q3StrList u; + if (!decode(e, u)) + return false; + + l.clear(); + for (uint i = 0; i < u.count(); ++i) { + QString lf = uriToLocalFile(u.at(i)); + if (!lf.isEmpty()) + l.append(lf); + } + return true; +} + +/*! + \fn bool Q3UriDrag::decodeToUnicodeUris(const QMimeSource *source, QStringList &list) + + Decodes URIs from the MIME \a source, converting them to Unicode URIs + (only useful for displaying to humans), and places them in the \a list + (which is first cleared). + + Returns true if the MIME \a source contained a valid list of URIs; + otherwise returns false. +*/ +bool Q3UriDrag::decodeToUnicodeUris(const QMimeSource* e, QStringList& l) +{ + Q3StrList u; + if (!decode(e, u)) + return false; + + l.clear(); + for (uint i = 0; i < u.count(); ++i) + l.append(uriToUnicodeUri(u.at(i))); + + return true; +} + +/*! + \class Q3ColorDrag + + \brief The Q3ColorDrag class provides a drag and drop object for + transferring colors between widgets. + + \compat + + This class provides a drag object which can be used to transfer data + about colors for drag and drop and in the clipboard. For example, it + is used in QColorDialog. + + The color is set in the constructor but can be changed with + setColor(). + + For more information about drag and drop, see the Q3DragObject class + and the \link dnd.html drag and drop documentation\endlink. +*/ + +/*! + Constructs a color drag object with the given \a col. Passes \a + dragsource and \a name to the Q3StoredDrag constructor. +*/ + +Q3ColorDrag::Q3ColorDrag(const QColor &col, QWidget *dragsource, const char *name) + : Q3StoredDrag("application/x-color", dragsource) +{ + setObjectName(QLatin1String(name)); + setColor(col); +} + +/*! + Constructs a color drag object with a white color. Passes \a + dragsource and \a name to the Q3StoredDrag constructor. +*/ + +Q3ColorDrag::Q3ColorDrag(QWidget *dragsource, const char *name) + : Q3StoredDrag("application/x-color", dragsource) +{ + setObjectName(QLatin1String(name)); + setColor(Qt::white); +} + +/*! + \fn void Q3ColorDrag::setColor(const QColor &color) + + Sets the \a color of the color drag. +*/ + +void Q3ColorDrag::setColor(const QColor &col) +{ + short r = (col.red() << 8) | col.red(); + short g = (col.green() << 8) | col.green(); + short b = (col.blue() << 8) | col.blue(); + + // make sure we transmit data in network order + r = htons(r); + g = htons(g); + b = htons(b); + + ushort rgba[4] = { + r, g, b, + 0xffff // Alpha not supported yet. + }; + QByteArray data; + data.resize(sizeof(rgba)); + memcpy(data.data(), rgba, sizeof(rgba)); + setEncodedData(data); +} + +/*! + \fn bool Q3ColorDrag::canDecode(QMimeSource *source) + + Returns true if the color drag object can decode the MIME \a source; + otherwise returns false. +*/ + +bool Q3ColorDrag::canDecode(QMimeSource *e) +{ + return e->provides("application/x-color"); +} + +/*! + \fn bool Q3ColorDrag::decode(QMimeSource *source, QColor &color) + + Decodes the MIME \a source, and sets the decoded values to the + given \a color. Returns true if the decoding is successful. + Returns false if the size of the encoded data is not the + expected size. +*/ + +bool Q3ColorDrag::decode(QMimeSource *e, QColor &col) +{ + QByteArray data = e->encodedData("application/x-color"); + ushort rgba[4]; + if (data.size() != sizeof(rgba)) + return false; + + memcpy(rgba, data.constData(), sizeof(rgba)); + + short r = rgba[0]; + short g = rgba[1]; + short b = rgba[2]; + short a = rgba[3]; + + // data is in network order + r = ntohs(r); + g = ntohs(g); + b = ntohs(b); + a = ntohs(a); + + r = (r >> 8) & 0xff; + g = (g >> 8) & 0xff; + b = (b >> 8) & 0xff; + a = (a >> 8) & 0xff; + + col.setRgb(r, g, b, a); + return true; +} + +QT_END_NAMESPACE diff --git a/src/qt3support/other/q3dragobject.h b/src/qt3support/other/q3dragobject.h new file mode 100644 index 0000000..10645c8 --- /dev/null +++ b/src/qt3support/other/q3dragobject.h @@ -0,0 +1,218 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3DRAGOBJECT_H +#define Q3DRAGOBJECT_H + +#include <QtCore/qobject.h> +#include <QtGui/qcolor.h> +#include <QtGui/qmime.h> +#include <QtGui/qimage.h> +#include <Qt3Support/q3strlist.h> +#include <QtCore/qlist.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class QWidget; +class Q3TextDragPrivate; +class Q3DragObjectPrivate; +class Q3StoredDragPrivate; +class Q3ImageDragPrivate; +class Q3ImageDrag; +class Q3TextDrag; +class Q3StrList; +class QImage; +class QPixmap; + +class Q_COMPAT_EXPORT Q3DragObject : public QObject, public QMimeSource { + Q_OBJECT + Q_DECLARE_PRIVATE(Q3DragObject) +public: + Q3DragObject(QWidget * dragSource = 0, const char *name = 0); + virtual ~Q3DragObject(); + + bool drag(); + bool dragMove(); + void dragCopy(); + void dragLink(); + + virtual void setPixmap(QPixmap); + virtual void setPixmap(QPixmap, const QPoint& hotspot); + QPixmap pixmap() const; + QPoint pixmapHotSpot() const; + + QWidget * source(); + static QWidget * target(); + + enum DragMode { DragDefault, DragCopy, DragMove, DragLink, DragCopyOrMove }; + +protected: + Q3DragObject(Q3DragObjectPrivate &, QWidget *dragSource = 0); + virtual bool drag(DragMode); + +private: + friend class QDragMime; + Q_DISABLE_COPY(Q3DragObject) +}; + +class Q_COMPAT_EXPORT Q3StoredDrag: public Q3DragObject { + Q_OBJECT + Q_DECLARE_PRIVATE(Q3StoredDrag) +public: + Q3StoredDrag(const char *mimeType, QWidget *dragSource = 0, const char *name = 0); + ~Q3StoredDrag(); + + virtual void setEncodedData(const QByteArray &); + + const char * format(int i) const; + virtual QByteArray encodedData(const char*) const; + +protected: + Q3StoredDrag(Q3StoredDragPrivate &, const char *mimeType, QWidget *dragSource = 0); + +private: + Q_DISABLE_COPY(Q3StoredDrag) +}; + +class Q_COMPAT_EXPORT Q3TextDrag: public Q3DragObject { + Q_OBJECT + Q_DECLARE_PRIVATE(Q3TextDrag) +public: + Q3TextDrag(const QString &, QWidget *dragSource = 0, const char *name = 0); + Q3TextDrag(QWidget * dragSource = 0, const char * name = 0); + ~Q3TextDrag(); + + virtual void setText(const QString &); + virtual void setSubtype(const QString &); + + const char * format(int i) const; + virtual QByteArray encodedData(const char*) const; + + static bool canDecode(const QMimeSource* e); + static bool decode(const QMimeSource* e, QString& s); + static bool decode(const QMimeSource* e, QString& s, QString& subtype); + +protected: + Q3TextDrag(Q3TextDragPrivate &, QWidget * dragSource = 0); + +private: + Q_DISABLE_COPY(Q3TextDrag) +}; + +class Q_COMPAT_EXPORT Q3ImageDrag: public Q3DragObject { + Q_OBJECT + Q_DECLARE_PRIVATE(Q3ImageDrag) +public: + Q3ImageDrag(QImage image, QWidget * dragSource = 0, const char * name = 0); + Q3ImageDrag(QWidget * dragSource = 0, const char * name = 0); + ~Q3ImageDrag(); + + virtual void setImage(QImage image); + + const char * format(int i) const; + virtual QByteArray encodedData(const char*) const; + + static bool canDecode(const QMimeSource* e); + static bool decode(const QMimeSource* e, QImage& i); + static bool decode(const QMimeSource* e, QPixmap& i); + +protected: + Q3ImageDrag(Q3ImageDragPrivate &, QWidget * dragSource = 0); + +private: + Q_DISABLE_COPY(Q3ImageDrag) +}; + + +class Q_COMPAT_EXPORT Q3UriDrag: public Q3StoredDrag { + Q_OBJECT + +public: + Q3UriDrag(const Q3StrList &uris, QWidget * dragSource = 0, const char * name = 0); + Q3UriDrag(QWidget * dragSource = 0, const char * name = 0); + ~Q3UriDrag(); + + void setFileNames(const QStringList & fnames); + inline void setFileNames(const QString & fname) { setFileNames(QStringList(fname)); } + void setFilenames(const QStringList & fnames) { setFileNames(fnames); } + inline void setFilenames(const QString & fname) { setFileNames(QStringList(fname)); } + void setUnicodeUris(const QStringList & uuris); + virtual void setUris(const QList<QByteArray> &uris); + + static QString uriToLocalFile(const char*); + static QByteArray localFileToUri(const QString&); + static QString uriToUnicodeUri(const char*); + static QByteArray unicodeUriToUri(const QString&); + static bool canDecode(const QMimeSource* e); + static bool decode(const QMimeSource* e, Q3StrList& i); + static bool decodeToUnicodeUris(const QMimeSource* e, QStringList& i); + static bool decodeLocalFiles(const QMimeSource* e, QStringList& i); + +private: + Q_DISABLE_COPY(Q3UriDrag) +}; + +class Q_COMPAT_EXPORT Q3ColorDrag : public Q3StoredDrag +{ + Q_OBJECT + QColor color; + +public: + Q3ColorDrag(const QColor &col, QWidget *dragsource = 0, const char *name = 0); + Q3ColorDrag(QWidget * dragSource = 0, const char * name = 0); + void setColor(const QColor &col); + + static bool canDecode(QMimeSource *); + static bool decode(QMimeSource *, QColor &col); + +private: + Q_DISABLE_COPY(Q3ColorDrag) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3DRAGOBJECT_H diff --git a/src/qt3support/other/q3dropsite.cpp b/src/qt3support/other/q3dropsite.cpp new file mode 100644 index 0000000..ef4ae29 --- /dev/null +++ b/src/qt3support/other/q3dropsite.cpp @@ -0,0 +1,82 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3dropsite.h" + +#ifndef QT_NO_DRAGANDDROP + +#include "qwidget.h" + +QT_BEGIN_NAMESPACE + +/*! + \class Q3DropSite + \brief The Q3DropSite class provides nothing and does nothing. + + \compat + + It was used in Qt 1.x to do some drag and drop; that has since been + folded into QWidget. + + \sa Q3DragObject, Q3TextDrag, Q3ImageDrag +*/ + +/*! + Constructs a Q3DropSite to handle events for the widget \a self. + + Pass \c this as the \a self parameter. + This enables dropping by calling QWidget::setAcceptDrops(true). +*/ +Q3DropSite::Q3DropSite(QWidget* self) +{ + self->setAcceptDrops(true); +} + +/*! + Destroys the drop site. +*/ +Q3DropSite::~Q3DropSite() +{ +} + +QT_END_NAMESPACE + +#endif // QT_NO_DRAGANDDROP diff --git a/src/qt3support/other/q3dropsite.h b/src/qt3support/other/q3dropsite.h new file mode 100644 index 0000000..211a6a9 --- /dev/null +++ b/src/qt3support/other/q3dropsite.h @@ -0,0 +1,65 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3DROPSITE_H +#define Q3DROPSITE_H + +#include <QtCore/qglobal.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class QWidget; + +class Q_COMPAT_EXPORT Q3DropSite { +public: + Q3DropSite(QWidget* parent); + virtual ~Q3DropSite(); +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QDROPSITE_H diff --git a/src/qt3support/other/q3gridlayout.h b/src/qt3support/other/q3gridlayout.h new file mode 100644 index 0000000..521920d --- /dev/null +++ b/src/qt3support/other/q3gridlayout.h @@ -0,0 +1,78 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3GRIDLAYOUT_H +#define Q3GRIDLAYOUT_H + +#include <QtGui/qboxlayout.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3GridLayout : public QGridLayout +{ +public: + inline explicit Q3GridLayout(QWidget *parent) + : QGridLayout(parent) { setMargin(0); setSpacing(0); } + + inline Q3GridLayout(QWidget *parent, int nRows, int nCols = 1, int margin = 0, + int spacing = -1, const char *name = 0) + : QGridLayout(parent, nRows, nCols, margin, spacing, name) {} + + inline Q3GridLayout(int nRows, int nCols = 1, int spacing = -1, const char *name = 0) + : QGridLayout(nRows, nCols, spacing, name) {} + + inline Q3GridLayout(QLayout *parentLayout, int nRows =1, int nCols = 1, int spacing = -1, + const char *name = 0) + : QGridLayout(parentLayout, nRows, nCols, spacing, name) {} + +private: + Q_DISABLE_COPY(Q3GridLayout) +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3GRIDLAYOUT_H diff --git a/src/qt3support/other/q3membuf.cpp b/src/qt3support/other/q3membuf.cpp new file mode 100644 index 0000000..4305bb7 --- /dev/null +++ b/src/qt3support/other/q3membuf.cpp @@ -0,0 +1,171 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3membuf_p.h" + +QT_BEGIN_NAMESPACE + +// ******************************************************************* +// QMembuf declaration and implementation +// ******************************************************************* + +/* \internal + This class implements an efficient buffering of data that is often used by + asynchronous IO classes like QSocket, QHttp and QProcess. +*/ + +Q3Membuf::Q3Membuf() : _size(0), _index(0) +{ +} + +Q3Membuf::~Q3Membuf() +{ + while (!buf.isEmpty()) + delete buf.takeFirst(); +} + +/*! \internal + This function consumes \a nbytes bytes of data from the + buffer and copies it into \a sink. If \a sink is a 0 pointer + the data goes into the nirvana. +*/ +bool Q3Membuf::consumeBytes(Q_ULONG nbytes, char *sink) +{ + if (nbytes <= 0 || (qint64)nbytes > _size) + return false; + _size -= nbytes; + while (!buf.isEmpty()) { + QByteArray *a = buf.first(); + if ((int)(_index + nbytes) >= a->size()) { + // Here we skip the whole byte array and get the next later + int len = a->size() - _index; + if (sink) { + memcpy(sink, a->constData()+_index, len); + sink += len; + } + nbytes -= len; + buf.removeFirst(); + delete a; + _index = 0; + if (nbytes == 0) + break; + } else { + // Here we skip only a part of the first byte array + if (sink) + memcpy(sink, a->constData()+_index, nbytes); + _index += nbytes; + break; + } + } + return true; +} + +/*! \internal + Scans for any occurrence of '\n' in the buffer. If \a store + is not 0 the text up to the first '\n' (or terminating 0) is + written to \a store, and a terminating 0 is appended to \a store + if necessary. Returns true if a '\n' was found; otherwise returns + false. +*/ +bool Q3Membuf::scanNewline(QByteArray *store) +{ + if (_size == 0) + return false; + int i = 0; // index into 'store' + QByteArray *a = 0; + char *p; + int n; + bool retval = false; + for (int j = 0; j < buf.size(); ++j) { + a = buf.at(j); + p = a->data(); + n = a->size(); + if (!j) { + // first buffer + p += _index; + n -= _index; + } + if (store) { + while (n-- > 0) { + *(store->data()+i) = *p; + if (++i == (int)store->size()) + store->resize(store->size() < 256 + ? 1024 : store->size()*4); + if (*p == '\n') { + retval = true; + goto end; + } + p++; + } + } else { + while (n-- > 0) { + if(*p == '\n') + return true; + p++; + } + } + } + end: + if (store) + store->resize(i); + return retval; +} + +int Q3Membuf::ungetch(int ch) +{ + if (buf.isEmpty() || _index==0) { + // we need a new QByteArray + QByteArray *ba = new QByteArray; + ba->resize(1); + buf.prepend(ba); + _size++; + (*ba)[0] = ch; + } else { + // we can reuse a place in the buffer + QByteArray *ba = buf.first(); + _index--; + _size++; + (*ba)[(int)_index] = ch; + } + return ch; +} + +QT_END_NAMESPACE diff --git a/src/qt3support/other/q3membuf_p.h b/src/qt3support/other/q3membuf_p.h new file mode 100644 index 0000000..29a74f9 --- /dev/null +++ b/src/qt3support/other/q3membuf_p.h @@ -0,0 +1,103 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3MEMBUF_P_H +#define Q3MEMBUF_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of a number of Qt sources files. This header file may change from +// version to version without notice, or even be removed. +// +// We mean it. +// + +#include "QtCore/qbytearray.h" +#include "QtCore/qlist.h" + +QT_BEGIN_NAMESPACE + +class Q_COMPAT_EXPORT Q3Membuf +{ +public: + Q3Membuf(); + ~Q3Membuf(); + + void append(QByteArray *ba); + void clear(); + + bool consumeBytes(Q_ULONG nbytes, char *sink); + QByteArray readAll(); + bool scanNewline(QByteArray *store); + bool canReadLine() const; + + int ungetch(int ch); + + qint64 size() const; + +private: + + QList<QByteArray *> buf; + qint64 _size; + qint64 _index; +}; + +inline void Q3Membuf::append(QByteArray *ba) +{ buf.append(ba); _size += ba->size(); } + +inline void Q3Membuf::clear() +{ qDeleteAll(buf); buf.clear(); _size=0; _index=0; } + +inline QByteArray Q3Membuf::readAll() +{ QByteArray ba; ba.resize(_size); consumeBytes(_size,ba.data()); return ba; } + +inline bool Q3Membuf::canReadLine() const +{ return const_cast<Q3Membuf*>(this)->scanNewline(0); } + +inline qint64 Q3Membuf::size() const +{ return _size; } + +QT_END_NAMESPACE + +#endif // Q3MEMBUF_P_H diff --git a/src/qt3support/other/q3mimefactory.cpp b/src/qt3support/other/q3mimefactory.cpp new file mode 100644 index 0000000..3fc3f61 --- /dev/null +++ b/src/qt3support/other/q3mimefactory.cpp @@ -0,0 +1,546 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3mimefactory.h" + +#ifndef QT_NO_MIMEFACTORY + +#include "qmap.h" +#include "qmime.h" +#include "qstringlist.h" +#include "qfileinfo.h" +#include "qdir.h" +#include "q3dragobject.h" +#include "qpixmap.h" +#include "qimagereader.h" +#include "q3cleanuphandler.h" +#include "private/qtextimagehandler_p.h" + +QT_BEGIN_NAMESPACE + +static Q3MimeSourceFactory* defaultfactory = 0; +static Q3SingleCleanupHandler<Q3MimeSourceFactory> qmime_cleanup_factory; + +class Q3MimeSourceFactoryData { +public: + Q3MimeSourceFactoryData() : + last(0) + { + } + + ~Q3MimeSourceFactoryData() + { + QMap<QString, QMimeSource*>::Iterator it = stored.begin(); + while (it != stored.end()) { + delete *it; + ++it; + } + delete last; + } + + QMap<QString, QMimeSource*> stored; + QMap<QString, QString> extensions; + QStringList path; + QMimeSource* last; + QList<Q3MimeSourceFactory*> factories; +}; + +static QImage richTextImageLoader(const QString &name, const QString &context) +{ + QImage img; + + const QMimeSource *src = Q3MimeSourceFactory::defaultFactory()->data(name, context); + if (src && Q3ImageDrag::decode(src, img)) + return img; + + return QImage(); +} + +/*! + \class Q3MimeSourceFactory + \brief The Q3MimeSourceFactory class is an extensible provider of mime-typed data. + + \compat + + A Q3MimeSourceFactory provides an abstract interface to a + collection of information. Each piece of information is + represented by a QMimeSource object which can be examined and + converted to concrete data types by functions such as + Q3ImageDrag::canDecode() and Q3ImageDrag::decode(). + + The base Q3MimeSourceFactory can be used in two ways: as an + abstraction of a collection of files or as specifically stored + data. For it to access files, call setFilePath() before accessing + data. For stored data, call setData() for each item (there are + also convenience functions, e.g. setText(), setImage() and + setPixmap(), that simply call setData() with appropriate + parameters). + + The rich text widgets, QTextEdit and QTextBrowser, use + Q3MimeSourceFactory to resolve references such as images or links + within rich text documents. They either access the default factory + (see \l{defaultFactory()}) or their own. Other classes that are + capable of displaying rich text (such as QLabel, QWhatsThis or + QMessageBox) always use the default factory. + + A factory can also be used as a container to store data associated + with a name. This technique is useful whenever rich text contains + images that are stored in the program itself, not loaded from the + hard disk. Your program may, for example, define some image data + as: + \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 0 + + To be able to use this image within some rich text, for example + inside a QLabel, you must create a QImage from the raw data and + insert it into the factory with a unique name: + \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 1 + + Now you can create a rich text QLabel with + + \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 2 + + When no longer needed, you can clear the data from the factory: + + \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 3 +*/ + + +/*! + Constructs a Q3MimeSourceFactory that has no file path and no + stored content. +*/ +Q3MimeSourceFactory::Q3MimeSourceFactory() : + d(new Q3MimeSourceFactoryData) +{ + addFilePath(QLatin1String(":/qt/q3mimesourcefactory/")); //to get from the resources + // add some reasonable defaults + setExtensionType(QLatin1String("htm"), "text/html;charset=iso8859-1"); + setExtensionType(QLatin1String("html"), "text/html;charset=iso8859-1"); + setExtensionType(QLatin1String("txt"), "text/plain"); + setExtensionType(QLatin1String("xml"), "text/xml;charset=UTF-8"); + setExtensionType(QLatin1String("jpg"), "image/jpeg"); // support misspelled jpeg files +} + +/*! + Destroys the Q3MimeSourceFactory, deleting all stored content. +*/ +Q3MimeSourceFactory::~Q3MimeSourceFactory() +{ + if (defaultFactory() == this) + defaultfactory = 0; + delete d; +} + +QMimeSource* Q3MimeSourceFactory::dataInternal(const QString& abs_name, const QMap<QString, QString> &extensions) const +{ + QMimeSource* r = 0; + QStringList attempted_names(abs_name); + QFileInfo fi(abs_name); + if (fi.isReadable()) { + // get the right mimetype + QString e = fi.extension(false); + QByteArray mimetype("application/octet-stream"); + if (extensions.contains(e)) + mimetype = extensions[e].latin1(); + if (!QImageReader::imageFormat(abs_name).isEmpty()) + mimetype = "application/x-qt-image"; + + QFile f(abs_name); + if (f.open(QIODevice::ReadOnly) && f.size()) { + QByteArray ba; + ba.resize(f.size()); + f.readBlock(ba.data(), ba.size()); + Q3StoredDrag* sr = new Q3StoredDrag(mimetype); + sr->setEncodedData(ba); + delete d->last; + d->last = r = sr; + } + } + + // we didn't find the mime-source, so ask the default factory for + // the mime-source (this one will iterate over all installed ones) + // + // this looks dangerous, as this dataInternal() function will be + // called again when the default factory loops over all installed + // factories (including this), but the static bool looping in + // data() avoids endless recursions + if (!r && this != defaultFactory()) + r = (QMimeSource*)defaultFactory()->data(abs_name); + + return r; +} + + +/*! + Returns a reference to the data associated with \a abs_name. The + return value remains valid only until the next data() or setData() + call, so you should immediately decode the result. + + If there is no data associated with \a abs_name in the factory's + store, the factory tries to access the local filesystem. If \a + abs_name isn't an absolute file name, the factory will search for + it in all defined paths (see \l{setFilePath()}). + + The factory understands all the image formats supported by + QImageReader. Any other mime types are determined by the file name + extension. The default settings are + \snippet doc/src/snippets/code/src_qt3support_other_q3mimefactory.cpp 4 + The effect of these is that file names ending in "txt" will be + treated as text encoded in the local encoding; those ending in + "xml" will be treated as text encoded in Unicode UTF-8 encoding. + The text/html type is treated specially, since the encoding can be + specified in the html file itself. "html" or "htm" will be treated + as text encoded in the encoding specified by the html meta tag, if + none could be found, the charset of the mime type will be used. + The text subtype ("html", "plain", or "xml") does not affect the + factory, but users of the factory may behave differently. We + recommend creating "xml" files where practical. These files can be + viewed regardless of the runtime encoding and can encode any + Unicode characters without resorting to encoding definitions + inside the file. + + Any file data that is not recognized will be retrieved as a + QMimeSource providing the "application/octet-stream" mime type, + meaning uninterpreted binary data. + + You can add further extensions or change existing ones with + subsequent calls to setExtensionType(). If the extension mechanism + is not sufficient for your problem domain, you can inherit + Q3MimeSourceFactory and reimplement this function to perform some + more specialized mime-type detection. The same applies if you want + to use the mime source factory to access URL referenced data over + a network. +*/ +const QMimeSource *Q3MimeSourceFactory::data(const QString& abs_name) const +{ + if (d->stored.contains(abs_name)) + return d->stored[abs_name]; + + const QMimeSource *r = 0; + if (abs_name.isEmpty()) + return r; + QStringList::Iterator it; + if (abs_name[0] == QLatin1Char('/') +#ifdef Q_WS_WIN + || (abs_name[0].isLetter() && abs_name[1] == QLatin1Char(':')) || abs_name.startsWith(QLatin1String("\\\\")) +#endif + ) + { + // handle absolute file names directly + r = dataInternal(abs_name, d->extensions); + } + else { // check list of paths + for (it = d->path.begin(); !r && it != d->path.end(); ++it) { + QString filename = *it; + if (filename[(int)filename.length()-1] != QLatin1Char('/')) + filename += QLatin1Char('/'); + filename += abs_name; + r = dataInternal(filename, d->extensions); + } + } + + static bool looping = false; + if (!r && this == defaultFactory()) { + // we found no mime-source and we are the default factory, so + // we know all the other installed mime-source factories, so + // ask them + if (!looping) { + // to avoid endless recustions, don't enter the loop below + // if data() got called from within the loop below + looping = true; + for (int i = 0; i < d->factories.size(); ++i) { + const Q3MimeSourceFactory *f = d->factories.at(i); + if (f == this) + continue; + r = static_cast<const QMimeSource *>(f->data(abs_name)); + if (r) { + looping = false; + return r; + } + } + looping = false; + } + } else if (!r) { + // we are not the default mime-source factory, so ask the + // default one for the mime-source, as this one will loop over + // all installed mime-source factories and ask these + r = static_cast<const QMimeSource *>(defaultFactory()->data(abs_name)); + } + return r; +} + +/*! + \fn void Q3MimeSourceFactory::setFilePath(const QStringList &path) + \fn void Q3MimeSourceFactory::setFilePath(const QString &path) + + Sets the list of directories that will be searched when named data + is requested to those given in the string list \a path. + + \sa filePath() +*/ +void Q3MimeSourceFactory::setFilePath(const QStringList& path) +{ + d->path = path; +} + +/*! + Returns the currently set search paths. +*/ +QStringList Q3MimeSourceFactory::filePath() const +{ + return d->path; +} + +/*! + Adds another search path, \a p to the existing search paths. + + \sa setFilePath() +*/ +void Q3MimeSourceFactory::addFilePath(const QString& p) +{ + d->path += p; +} + +/*! + Sets the mime-type to be associated with the file name extension, + \a ext to \a mimetype. This determines the mime-type for files + found via the paths set by setFilePath(). +*/ +void Q3MimeSourceFactory::setExtensionType(const QString& ext, const char* mimetype) +{ + d->extensions.insert(ext, QLatin1String(mimetype)); +} + +/*! + Converts the absolute or relative data item name \a + abs_or_rel_name to an absolute name, interpreted within the + context (path) of the data item named \a context (this must be an + absolute name). +*/ +QString Q3MimeSourceFactory::makeAbsolute(const QString& abs_or_rel_name, const QString& context) const +{ + if (context.isNull() || + !(context[0] == QLatin1Char('/') +#ifdef Q_WS_WIN + || (context[0].isLetter() && context[1] == QLatin1Char(':')) +#endif + )) + return abs_or_rel_name; + if (abs_or_rel_name.isEmpty()) + return context; + QFileInfo c(context); + if (!c.isDir()) { + QFileInfo r(c.dir(true), abs_or_rel_name); + return r.absFilePath(); + } else { + QDir d(context); + QFileInfo r(d, abs_or_rel_name); + return r.absFilePath(); + } +} + +/*! + \overload + A convenience function. See data(const QString& abs_name). The + file name is given in \a abs_or_rel_name and the path is in \a + context. +*/ +const QMimeSource* Q3MimeSourceFactory::data(const QString& abs_or_rel_name, const QString& context) const +{ + const QMimeSource* r = data(makeAbsolute(abs_or_rel_name,context)); + if (!r && !d->path.isEmpty()) + r = data(abs_or_rel_name); + return r; +} + + +/*! + Sets \a text to be the data item associated with the absolute name + \a abs_name. + + Equivalent to setData(abs_name, new Q3TextDrag(text)). +*/ +void Q3MimeSourceFactory::setText(const QString& abs_name, const QString& text) +{ + setData(abs_name, new Q3TextDrag(text)); +} + +/*! + Sets \a image to be the data item associated with the absolute + name \a abs_name. + + Equivalent to setData(abs_name, new Q3ImageDrag(image)). +*/ +void Q3MimeSourceFactory::setImage(const QString& abs_name, const QImage& image) +{ + setData(abs_name, new Q3ImageDrag(image)); +} + +/*! + Sets \a pixmap to be the data item associated with the absolute + name \a abs_name. +*/ +void Q3MimeSourceFactory::setPixmap(const QString& abs_name, const QPixmap& pixmap) +{ + setData(abs_name, new Q3ImageDrag(pixmap.convertToImage())); +} + +/*! + Sets \a data to be the data item associated with + the absolute name \a abs_name. Note that the ownership of \a data is + transferred to the factory: do not delete or access the pointer after + passing it to this function. + + Passing 0 for data removes previously stored data. +*/ +void Q3MimeSourceFactory::setData(const QString& abs_name, QMimeSource* data) +{ + if (d->stored.contains(abs_name)) + delete d->stored[abs_name]; + d->stored.insert(abs_name,data); +} + + +/*! + Returns the application-wide default mime source factory. This + factory is used by rich text rendering classes such as + QSimpleRichText, QWhatsThis and QMessageBox to resolve named + references within rich text documents. It serves also as the + initial factory for the more complex render widgets, QTextEdit and + QTextBrowser. + + \sa setDefaultFactory() +*/ +Q3MimeSourceFactory* Q3MimeSourceFactory::defaultFactory() +{ + if (!defaultfactory) + { + defaultfactory = new Q3MimeSourceFactory(); + qmime_cleanup_factory.set(&defaultfactory); + QTextImageHandler::externalLoader = richTextImageLoader; + } + return defaultfactory; +} + +/*! + Sets the default \a factory, destroying any previously set mime + source provider. The ownership of the factory is transferred to + Qt. + + \sa defaultFactory() +*/ +void Q3MimeSourceFactory::setDefaultFactory(Q3MimeSourceFactory* factory) +{ + if (!defaultfactory) + qmime_cleanup_factory.set(&defaultfactory); + else if (defaultfactory != factory) + delete defaultfactory; + defaultfactory = factory; +} + +/*! + Sets the defaultFactory() to 0 and returns the previous one. +*/ + +Q3MimeSourceFactory* Q3MimeSourceFactory::takeDefaultFactory() +{ + Q3MimeSourceFactory *f = defaultfactory; + defaultfactory = 0; + return f; +} + +/*! + Adds the Q3MimeSourceFactory \a f to the list of available + mimesource factories. If the defaultFactory() can't resolve a + data() it iterates over the list of installed mimesource factories + until the data can be resolved. + + \sa removeFactory() +*/ + +void Q3MimeSourceFactory::addFactory(Q3MimeSourceFactory *f) +{ + Q3MimeSourceFactory::defaultFactory()->d->factories.append(f); +} + +/*! + Removes the mimesource factory \a f from the list of available + mimesource factories. + + \sa addFactory() +*/ + +void Q3MimeSourceFactory::removeFactory(Q3MimeSourceFactory *f) +{ + Q3MimeSourceFactory::defaultFactory()->d->factories.removeAll(f); +} + +QPixmap qPixmapFromMimeSource(const QString &abs_name) +{ + const QMimeSource *m = Q3MimeSourceFactory::defaultFactory()->data(abs_name); + if (!m) { + if (QFile::exists(abs_name)) + return QPixmap(abs_name); + if (!abs_name.isEmpty()) + qWarning("QPixmap::fromMimeSource: Cannot find pixmap \"%s\" in the mime source factory", + abs_name.latin1()); + return QPixmap(); + } + QPixmap pix; + Q3ImageDrag::decode(m, pix); + return pix; +} + +QImage qImageFromMimeSource(const QString &abs_name) +{ + const QMimeSource *m = Q3MimeSourceFactory::defaultFactory()->data(abs_name); + if (!m) { + qWarning("QImage::fromMimeSource: Cannot find image \"%s\" in the mime source factory", abs_name.latin1()); + return QImage(); + } + QImage img; + Q3ImageDrag::decode(m, img); + return img; +} + +QT_END_NAMESPACE + +#endif // QT_NO_MIMEFACTORY diff --git a/src/qt3support/other/q3mimefactory.h b/src/qt3support/other/q3mimefactory.h new file mode 100644 index 0000000..e21f63b --- /dev/null +++ b/src/qt3support/other/q3mimefactory.h @@ -0,0 +1,102 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3MIMEFACTORY_H +#define Q3MIMEFACTORY_H + +#include <QtGui/qwindowdefs.h> +#include <QtCore/qstring.h> +#include <QtCore/qmap.h> +#include <QtGui/qpixmap.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_MIMEFACTORY + +class QStringList; +class QMimeSource; +class Q3MimeSourceFactoryData; + +class Q_COMPAT_EXPORT Q3MimeSourceFactory { +public: + Q3MimeSourceFactory(); + virtual ~Q3MimeSourceFactory(); + + static Q3MimeSourceFactory* defaultFactory(); + static void setDefaultFactory(Q3MimeSourceFactory*); + static Q3MimeSourceFactory* takeDefaultFactory(); + static void addFactory(Q3MimeSourceFactory *f); + static void removeFactory(Q3MimeSourceFactory *f); + + virtual const QMimeSource* data(const QString& abs_name) const; + virtual QString makeAbsolute(const QString& abs_or_rel_name, const QString& context) const; + const QMimeSource* data(const QString& abs_or_rel_name, const QString& context) const; + + virtual void setText(const QString& abs_name, const QString& text); + virtual void setImage(const QString& abs_name, const QImage& im); + virtual void setPixmap(const QString& abs_name, const QPixmap& pm); + virtual void setData(const QString& abs_name, QMimeSource* data); + virtual void setFilePath(const QStringList&); + inline void setFilePath(const QString &path) { setFilePath(QStringList(path)); } + virtual QStringList filePath() const; + void addFilePath(const QString&); + virtual void setExtensionType(const QString& ext, const char* mimetype); + +private: + QMimeSource *dataInternal(const QString& abs_name, const QMap<QString, QString> &extensions) const; + Q3MimeSourceFactoryData* d; +}; + +Q_COMPAT_EXPORT QPixmap qPixmapFromMimeSource(const QString &abs_name); + +Q_COMPAT_EXPORT QImage qImageFromMimeSource(const QString &abs_name); + +#endif // QT_NO_MIMEFACTORY + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3MIMEFACTORY_H diff --git a/src/qt3support/other/q3polygonscanner.cpp b/src/qt3support/other/q3polygonscanner.cpp new file mode 100644 index 0000000..da1af1e --- /dev/null +++ b/src/qt3support/other/q3polygonscanner.cpp @@ -0,0 +1,939 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3polygonscanner.h" +#include "q3pointarray.h" +#include <stdlib.h> + +QT_BEGIN_NAMESPACE + +// Based on Xserver code miFillGeneralPoly... +/* + * + * Written by Brian Kelleher; Oct. 1985 + * + * Routine to fill a polygon. Two fill rules are + * supported: frWINDING and frEVENODD. + * + * See fillpoly.h for a complete description of the algorithm. + */ + +/* + * These are the data structures needed to scan + * convert regions. Two different scan conversion + * methods are available -- the even-odd method, and + * the winding number method. + * The even-odd rule states that a point is inside + * the polygon if a ray drawn from that point in any + * direction will pass through an odd number of + * path segments. + * By the winding number rule, a point is decided + * to be inside the polygon if a ray drawn from that + * point in any direction passes through a different + * number of clockwise and counterclockwise path + * segments. + * + * These data structures are adapted somewhat from + * the algorithm in (Foley/Van Dam) for scan converting + * polygons. + * The basic algorithm is to start at the top (smallest y) + * of the polygon, stepping down to the bottom of + * the polygon by incrementing the y coordinate. We + * keep a list of edges which the current scanline crosses, + * sorted by x. This list is called the Active Edge Table (AET) + * As we change the y-coordinate, we update each entry in + * in the active edge table to reflect the edges new xcoord. + * This list must be sorted at each scanline in case + * two edges intersect. + * We also keep a data structure known as the Edge Table (ET), + * which keeps track of all the edges which the current + * scanline has not yet reached. The ET is basically a + * list of ScanLineList structures containing a list of + * edges which are entered at a given scanline. There is one + * ScanLineList per scanline at which an edge is entered. + * When we enter a new edge, we move it from the ET to the AET. + * + * From the AET, we can implement the even-odd rule as in + * (Foley/Van Dam). + * The winding number rule is a little trickier. We also + * keep the EdgeTableEntries in the AET linked by the + * nextWETE (winding EdgeTableEntry) link. This allows + * the edges to be linked just as before for updating + * purposes, but only uses the edges linked by the nextWETE + * link as edges representing spans of the polygon to + * drawn (as with the even-odd rule). + */ + +/* $XConsortium: miscanfill.h,v 1.5 94/04/17 20:27:50 dpw Exp $ */ +/* + +Copyright (c) 1987 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from the X Consortium. + +*/ + + +/* + * scanfill.h + * + * Written by Brian Kelleher; Jan 1985 + * + * This file contains a few macros to help track + * the edge of a filled object. The object is assumed + * to be filled in scanline order, and thus the + * algorithm used is an extension of Bresenham's line + * drawing algorithm which assumes that y is always the + * major axis. + * Since these pieces of code are the same for any filled shape, + * it is more convenient to gather the library in one + * place, but since these pieces of code are also in + * the inner loops of output primitives, procedure call + * overhead is out of the question. + * See the author for a derivation if needed. + */ + +/* + * In scan converting polygons, we want to choose those pixels + * which are inside the polygon. Thus, we add .5 to the starting + * x coordinate for both left and right edges. Now we choose the + * first pixel which is inside the pgon for the left edge and the + * first pixel which is outside the pgon for the right edge. + * Draw the left pixel, but not the right. + * + * How to add .5 to the starting x coordinate: + * If the edge is moving to the right, then subtract dy from the + * error term from the general form of the algorithm. + * If the edge is moving to the left, then add dy to the error term. + * + * The reason for the difference between edges moving to the left + * and edges moving to the right is simple: If an edge is moving + * to the right, then we want the algorithm to flip immediately. + * If it is moving to the left, then we don't want it to flip until + * we traverse an entire pixel. + */ +#define BRESINITPGON(dy, x1, x2, xStart, d, m, m1, incr1, incr2) { \ + int dx; /* local storage */ \ +\ + /* \ + * if the edge is horizontal, then it is ignored \ + * and assumed not to be processed. Otherwise, do this stuff. \ + */ \ + if ((dy) != 0) { \ + xStart = (x1); \ + dx = (x2) - xStart; \ + if (dx < 0) { \ + m = dx / (dy); \ + m1 = m - 1; \ + incr1 = -2 * dx + 2 * (dy) * m1; \ + incr2 = -2 * dx + 2 * (dy) * m; \ + d = 2 * m * (dy) - 2 * dx - 2 * (dy); \ + } else { \ + m = dx / (dy); \ + m1 = m + 1; \ + incr1 = 2 * dx - 2 * (dy) * m1; \ + incr2 = 2 * dx - 2 * (dy) * m; \ + d = -2 * m * (dy) + 2 * dx; \ + } \ + } \ +} + +#define BRESINCRPGON(d, minval, m, m1, incr1, incr2) { \ + if (m1 > 0) { \ + if (d > 0) { \ + minval += m1; \ + d += incr1; \ + } \ + else { \ + minval += m; \ + d += incr2; \ + } \ + } else {\ + if (d >= 0) { \ + minval += m1; \ + d += incr1; \ + } \ + else { \ + minval += m; \ + d += incr2; \ + } \ + } \ +} + + +/* + * This structure contains all of the information needed + * to run the bresenham algorithm. + * The variables may be hardcoded into the declarations + * instead of using this structure to make use of + * register declarations. + */ +typedef struct { + int minor; /* minor axis */ + int d; /* decision variable */ + int m, m1; /* slope and slope+1 */ + int incr1, incr2; /* error increments */ +} BRESINFO; + + +#define BRESINITPGONSTRUCT(dmaj, min1, min2, bres) \ + BRESINITPGON(dmaj, min1, min2, bres.minor, bres.d, \ + bres.m, bres.m1, bres.incr1, bres.incr2) + +#define BRESINCRPGONSTRUCT(bres) \ + BRESINCRPGON(bres.d, bres.minor, bres.m, bres.m1, bres.incr1, bres.incr2) + + +typedef struct _EdgeTableEntry { + int ymax; /* ycoord at which we exit this edge. */ + BRESINFO bres; /* Bresenham info to run the edge */ + struct _EdgeTableEntry *next; /* next in the list */ + struct _EdgeTableEntry *back; /* for insertion sort */ + struct _EdgeTableEntry *nextWETE; /* for winding num rule */ + int ClockWise; /* flag for winding number rule */ +} EdgeTableEntry; + + +typedef struct _ScanLineList{ + int scanline; /* the scanline represented */ + EdgeTableEntry *edgelist; /* header node */ + struct _ScanLineList *next; /* next in the list */ +} ScanLineList; + + +typedef struct { + int ymax; /* ymax for the polygon */ + int ymin; /* ymin for the polygon */ + ScanLineList scanlines; /* header node */ +} EdgeTable; + + +/* + * Here is a struct to help with storage allocation + * so we can allocate a big chunk at a time, and then take + * pieces from this heap when we need to. + */ +#define SLLSPERBLOCK 25 + +typedef struct _ScanLineListBlock { + ScanLineList SLLs[SLLSPERBLOCK]; + struct _ScanLineListBlock *next; +} ScanLineListBlock; + +/* + * number of points to buffer before sending them off + * to scanlines() : Must be an even number + */ +#define NUMPTSTOBUFFER 200 + +/* + * + * a few macros for the inner loops of the fill code where + * performance considerations don't allow a procedure call. + * + * Evaluate the given edge at the given scanline. + * If the edge has expired, then we leave it and fix up + * the active edge table; otherwise, we increment the + * x value to be ready for the next scanline. + * The winding number rule is in effect, so we must notify + * the caller when the edge has been removed so he + * can reorder the Winding Active Edge Table. + */ +#define EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET) { \ + if (pAET->ymax == y) { /* leaving this edge */ \ + pPrevAET->next = pAET->next; \ + pAET = pPrevAET->next; \ + fixWAET = 1; \ + if (pAET) \ + pAET->back = pPrevAET; \ + } \ + else { \ + BRESINCRPGONSTRUCT(pAET->bres); \ + pPrevAET = pAET; \ + pAET = pAET->next; \ + } \ +} + + +/* + * Evaluate the given edge at the given scanline. + * If the edge has expired, then we leave it and fix up + * the active edge table; otherwise, we increment the + * x value to be ready for the next scanline. + * The even-odd rule is in effect. + */ +#define EVALUATEEDGEEVENODD(pAET, pPrevAET, y) { \ + if (pAET->ymax == y) { /* leaving this edge */ \ + pPrevAET->next = pAET->next; \ + pAET = pPrevAET->next; \ + if (pAET) \ + pAET->back = pPrevAET; \ + } \ + else { \ + BRESINCRPGONSTRUCT(pAET->bres) \ + pPrevAET = pAET; \ + pAET = pAET->next; \ + } \ +} + +/*********************************************************** + +Copyright (c) 1987 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +#define MAXINT 0x7fffffff +#define MININT -MAXINT + +/* + * fillUtils.c + * + * Written by Brian Kelleher; Oct. 1985 + * + * This module contains all of the utility functions + * needed to scan convert a polygon. + * + */ +/* + * InsertEdgeInET + * + * Insert the given edge into the edge table. + * First we must find the correct bucket in the + * Edge table, then find the right slot in the + * bucket. Finally, we can insert it. + * + */ +static bool +miInsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE, + int scanline, ScanLineListBlock **SLLBlock, int *iSLLBlock) +{ + register EdgeTableEntry *start, *prev; + register ScanLineList *pSLL, *pPrevSLL; + ScanLineListBlock *tmpSLLBlock; + + /* + * find the right bucket to put the edge into + */ + pPrevSLL = &ET->scanlines; + pSLL = pPrevSLL->next; + while (pSLL && (pSLL->scanline < scanline)) + { + pPrevSLL = pSLL; + pSLL = pSLL->next; + } + + /* + * reassign pSLL (pointer to ScanLineList) if necessary + */ + if ((!pSLL) || (pSLL->scanline > scanline)) + { + if (*iSLLBlock > SLLSPERBLOCK-1) + { + tmpSLLBlock = + (ScanLineListBlock *)malloc(sizeof(ScanLineListBlock)); + if (!tmpSLLBlock) + return false; + (*SLLBlock)->next = tmpSLLBlock; + tmpSLLBlock->next = 0; + *SLLBlock = tmpSLLBlock; + *iSLLBlock = 0; + } + pSLL = &((*SLLBlock)->SLLs[(*iSLLBlock)++]); + + pSLL->next = pPrevSLL->next; + pSLL->edgelist = 0; + pPrevSLL->next = pSLL; + } + pSLL->scanline = scanline; + + /* + * now insert the edge in the right bucket + */ + prev = 0; + start = pSLL->edgelist; + while (start && (start->bres.minor < ETE->bres.minor)) + { + prev = start; + start = start->next; + } + ETE->next = start; + + if (prev) + prev->next = ETE; + else + pSLL->edgelist = ETE; + return true; +} + +/* + * CreateEdgeTable + * + * This routine creates the edge table for + * scan converting polygons. + * The Edge Table (ET) looks like: + * + * EdgeTable + * -------- + * | ymax | ScanLineLists + * |scanline|-->------------>-------------->... + * -------- |scanline| |scanline| + * |edgelist| |edgelist| + * --------- --------- + * | | + * | | + * V V + * list of ETEs list of ETEs + * + * where ETE is an EdgeTableEntry data structure, + * and there is one ScanLineList per scanline at + * which an edge is initially entered. + * + */ + +typedef struct { +#if defined(Q_OS_MAC) + int y, x; +#else + int x, y; +#endif + +} DDXPointRec, *DDXPointPtr; + +/* + * Clean up our act. + */ +static void +miFreeStorage(ScanLineListBlock *pSLLBlock) +{ + register ScanLineListBlock *tmpSLLBlock; + + while (pSLLBlock) + { + tmpSLLBlock = pSLLBlock->next; + free(pSLLBlock); + pSLLBlock = tmpSLLBlock; + } +} + +static bool +miCreateETandAET(int count, DDXPointPtr pts, EdgeTable *ET, + EdgeTableEntry *AET, EdgeTableEntry *pETEs, ScanLineListBlock *pSLLBlock) +{ + register DDXPointPtr top, bottom; + register DDXPointPtr PrevPt, CurrPt; + int iSLLBlock = 0; + + int dy; + + if (count < 2) return true; + + /* + * initialize the Active Edge Table + */ + AET->next = 0; + AET->back = 0; + AET->nextWETE = 0; + AET->bres.minor = MININT; + + /* + * initialize the Edge Table. + */ + ET->scanlines.next = 0; + ET->ymax = MININT; + ET->ymin = MAXINT; + pSLLBlock->next = 0; + + PrevPt = &pts[count-1]; + + /* + * for each vertex in the array of points. + * In this loop we are dealing with two vertices at + * a time -- these make up one edge of the polygon. + */ + while (count--) + { + CurrPt = pts++; + + /* + * find out which point is above and which is below. + */ + if (PrevPt->y > CurrPt->y) + { + bottom = PrevPt, top = CurrPt; + pETEs->ClockWise = 0; + } + else + { + bottom = CurrPt, top = PrevPt; + pETEs->ClockWise = 1; + } + + /* + * don't add horizontal edges to the Edge table. + */ + if (bottom->y != top->y) + { + pETEs->ymax = bottom->y-1; /* -1 so we don't get last scanline */ + + /* + * initialize integer edge algorithm + */ + dy = bottom->y - top->y; + BRESINITPGONSTRUCT(dy, top->x, bottom->x, pETEs->bres) + + if (!miInsertEdgeInET(ET, pETEs, top->y, &pSLLBlock, &iSLLBlock)) + { + miFreeStorage(pSLLBlock->next); + return false; + } + + ET->ymax = qMax(ET->ymax, PrevPt->y); + ET->ymin = qMin(ET->ymin, PrevPt->y); + pETEs++; + } + + PrevPt = CurrPt; + } + return true; +} + +/* + * loadAET + * + * This routine moves EdgeTableEntries from the + * EdgeTable into the Active Edge Table, + * leaving them sorted by smaller x coordinate. + * + */ + +static void +miloadAET(EdgeTableEntry *AET, EdgeTableEntry *ETEs) +{ + register EdgeTableEntry *pPrevAET; + register EdgeTableEntry *tmp; + + pPrevAET = AET; + AET = AET->next; + while (ETEs) + { + while (AET && (AET->bres.minor < ETEs->bres.minor)) + { + pPrevAET = AET; + AET = AET->next; + } + tmp = ETEs->next; + ETEs->next = AET; + if (AET) + AET->back = ETEs; + ETEs->back = pPrevAET; + pPrevAET->next = ETEs; + pPrevAET = ETEs; + + ETEs = tmp; + } +} + +/* + * computeWAET + * + * This routine links the AET by the + * nextWETE (winding EdgeTableEntry) link for + * use by the winding number rule. The final + * Active Edge Table (AET) might look something + * like: + * + * AET + * ---------- --------- --------- + * |ymax | |ymax | |ymax | + * | ... | |... | |... | + * |next |->|next |->|next |->... + * |nextWETE| |nextWETE| |nextWETE| + * --------- --------- ^-------- + * | | | + * V-------------------> V---> ... + * + */ +static void +micomputeWAET(EdgeTableEntry *AET) +{ + register EdgeTableEntry *pWETE; + register int inside = 1; + register int isInside = 0; + + AET->nextWETE = 0; + pWETE = AET; + AET = AET->next; + while (AET) + { + if (AET->ClockWise) + isInside++; + else + isInside--; + + if ((!inside && !isInside) || + (inside && isInside)) + { + pWETE->nextWETE = AET; + pWETE = AET; + inside = !inside; + } + AET = AET->next; + } + pWETE->nextWETE = 0; +} + +/* + * InsertionSort + * + * Just a simple insertion sort using + * pointers and back pointers to sort the Active + * Edge Table. + * + */ + +static int +miInsertionSort(EdgeTableEntry *AET) +{ + register EdgeTableEntry *pETEchase; + register EdgeTableEntry *pETEinsert; + register EdgeTableEntry *pETEchaseBackTMP; + register int changed = 0; + + AET = AET->next; + while (AET) + { + pETEinsert = AET; + pETEchase = AET; + while (pETEchase->back->bres.minor > AET->bres.minor) + pETEchase = pETEchase->back; + + AET = AET->next; + if (pETEchase != pETEinsert) + { + pETEchaseBackTMP = pETEchase->back; + pETEinsert->back->next = AET; + if (AET) + AET->back = pETEinsert->back; + pETEinsert->next = pETEchase; + pETEchase->back->next = pETEinsert; + pETEchase->back = pETEinsert; + pETEinsert->back = pETEchaseBackTMP; + changed = 1; + } + } + return changed; +} + +/*! + \overload +*/ +void Q3PolygonScanner::scan(const Q3PointArray& pa, bool winding, int index, int npoints) +{ + scan(pa, winding, index, npoints, true); +} + +/*! + \overload + + If \a stitchable is false, the right and bottom edges of the + polygon are included. This causes adjacent polygons to overlap. +*/ +void Q3PolygonScanner::scan(const Q3PointArray& pa, bool winding, int index, int npoints, bool stitchable) +{ + scan(pa, winding, index, npoints, + stitchable ? Edge(Left+Top) : Edge(Left+Right+Top+Bottom)); +} + +/*! + Calls processSpans() for all scanlines of the polygon defined by + \a npoints starting at \a index in \a pa. + + If \a winding is true, the Winding algorithm rather than the + Odd-Even rule is used. + + The \a edges is any bitwise combination of: + \list + \i Q3PolygonScanner::Left + \i Q3PolygonScanner::Right + \i Q3PolygonScanner::Top + \i Q3PolygonScanner::Bottom + \endlist + \a edges determines which edges are included. + + \warning The edges feature does not work properly. + +*/ +void Q3PolygonScanner::scan(const Q3PointArray& pa, bool winding, int index, int npoints, Edge edges) +{ + + + DDXPointPtr ptsIn = (DDXPointPtr)pa.data(); + ptsIn += index; + register EdgeTableEntry *pAET; /* the Active Edge Table */ + register int y; /* the current scanline */ + register int nPts = 0; /* number of pts in buffer */ + register EdgeTableEntry *pWETE; /* Winding Edge Table */ + register ScanLineList *pSLL; /* Current ScanLineList */ + register DDXPointPtr ptsOut; /* ptr to output buffers */ + int *width; + DDXPointRec FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */ + int FirstWidth[NUMPTSTOBUFFER]; + EdgeTableEntry *pPrevAET; /* previous AET entry */ + EdgeTable ET; /* Edge Table header node */ + EdgeTableEntry AET; /* Active ET header node */ + EdgeTableEntry *pETEs; /* Edge Table Entries buff */ + ScanLineListBlock SLLBlock; /* header for ScanLineList */ + int fixWAET = 0; + int edge_l = (edges & Left) ? 1 : 0; + int edge_r = (edges & Right) ? 1 : 0; + int edge_t = 1; //#### (edges & Top) ? 1 : 0; + int edge_b = (edges & Bottom) ? 1 : 0; + + if (npoints == -1) + npoints = pa.size(); + + if (npoints < 3) + return; + + if(!(pETEs = (EdgeTableEntry *) + malloc(sizeof(EdgeTableEntry) * npoints))) + return; + ptsOut = FirstPoint; + width = FirstWidth; + if (!miCreateETandAET(npoints, ptsIn, &ET, &AET, pETEs, &SLLBlock)) + { + free(pETEs); + return; + } + pSLL = ET.scanlines.next; + + if (!winding) + { + /* + * for each scanline + */ + for (y = ET.ymin+1-edge_t; y < ET.ymax+edge_b; y++) + { + /* + * Add a new edge to the active edge table when we + * get to the next edge. + */ + if (pSLL && y == pSLL->scanline) + { + miloadAET(&AET, pSLL->edgelist); + pSLL = pSLL->next; + } + pPrevAET = &AET; + pAET = AET.next; + + /* + * for each active edge + */ + while (pAET) + { + ptsOut->x = pAET->bres.minor + 1 - edge_l; + ptsOut++->y = y; + *width++ = pAET->next->bres.minor - pAET->bres.minor + - 1 + edge_l + edge_r; + nPts++; + + /* + * send out the buffer when its full + */ + if (nPts == NUMPTSTOBUFFER) + { + processSpans(nPts, (QPoint*)FirstPoint, FirstWidth); + ptsOut = FirstPoint; + width = FirstWidth; + nPts = 0; + } + EVALUATEEDGEEVENODD(pAET, pPrevAET, y) + EVALUATEEDGEEVENODD(pAET, pPrevAET, y) + } + miInsertionSort(&AET); + } + } + else /* default to WindingNumber */ + { + /* + * for each scanline + */ + for (y = ET.ymin+1-edge_t; y < ET.ymax+edge_b; y++) + { + /* + * Add a new edge to the active edge table when we + * get to the next edge. + */ + if (pSLL && y == pSLL->scanline) + { + miloadAET(&AET, pSLL->edgelist); + micomputeWAET(&AET); + pSLL = pSLL->next; + } + pPrevAET = &AET; + pAET = AET.next; + pWETE = pAET; + + /* + * for each active edge + */ + while (pAET) + { + /* + * if the next edge in the active edge table is + * also the next edge in the winding active edge + * table. + */ + if (pWETE == pAET) + { + ptsOut->x = pAET->bres.minor + 1 - edge_l; + ptsOut++->y = y; + *width++ = pAET->nextWETE->bres.minor - pAET->bres.minor - 1 + edge_l + edge_r; + nPts++; + + /* + * send out the buffer + */ + if (nPts == NUMPTSTOBUFFER) + { + processSpans(nPts, (QPoint*)FirstPoint, FirstWidth); + ptsOut = FirstPoint; + width = FirstWidth; + nPts = 0; + } + + pWETE = pWETE->nextWETE; + while (pWETE != pAET) { + EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET) + } + pWETE = pWETE->nextWETE; + } + EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET) + } + + /* + * reevaluate the Winding active edge table if we + * just had to resort it or if we just exited an edge. + */ + if (miInsertionSort(&AET) || fixWAET) + { + micomputeWAET(&AET); + fixWAET = 0; + } + } + } + + /* + * Get any spans that we missed by buffering + */ + + + processSpans(nPts, (QPoint*)FirstPoint, FirstWidth); + free(pETEs); + miFreeStorage(SLLBlock.next); +} +/***** END OF X11-based CODE *****/ + +QT_END_NAMESPACE diff --git a/src/qt3support/other/q3polygonscanner.h b/src/qt3support/other/q3polygonscanner.h new file mode 100644 index 0000000..7071825 --- /dev/null +++ b/src/qt3support/other/q3polygonscanner.h @@ -0,0 +1,70 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3POLYGONSCANNER_H +#define Q3POLYGONSCANNER_H + +#include <QtCore/qglobal.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +class Q3PointArray; +class QPoint; + +class Q_COMPAT_EXPORT Q3PolygonScanner { +public: + virtual ~Q3PolygonScanner() {} + void scan(const Q3PointArray& pa, bool winding, int index=0, int npoints=-1); + void scan(const Q3PointArray& pa, bool winding, int index, int npoints, bool stitchable); + enum Edge { Left=1, Right=2, Top=4, Bottom=8 }; + void scan(const Q3PointArray& pa, bool winding, int index, int npoints, Edge edges); + virtual void processSpans(int n, QPoint* point, int* width)=0; +}; + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3POLYGONSCANNER_H diff --git a/src/qt3support/other/q3process.cpp b/src/qt3support/other/q3process.cpp new file mode 100644 index 0000000..6eac812 --- /dev/null +++ b/src/qt3support/other/q3process.cpp @@ -0,0 +1,927 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "q3process.h" + +#ifndef QT_NO_PROCESS + +#include "qapplication.h" +#include "private/q3membuf_p.h" + +#include <stdio.h> +#include <stdlib.h> + +QT_BEGIN_NAMESPACE + +//#define QT_Q3PROCESS_DEBUG + + +/*! + \class Q3Process + + \brief The Q3Process class is used to start external programs and + to communicate with them. + + \compat + + You can write to the started program's standard input, and can + read the program's standard output and standard error. You can + pass command line arguments to the program either in the + constructor or with setArguments() or addArgument(). The program's + working directory can be set with setWorkingDirectory(). If you + need to set up environment variables pass them to the start() or + launch() functions (see below). The processExited() signal is + emitted if the program exits. The program's exit status is + available from exitStatus(), although you could simply call + normalExit() to see if the program terminated normally. + + There are two different ways to start a process. If you just want + to run a program, optionally passing data to its standard input at + the beginning, use one of the launch() functions. If you want full + control of the program's standard input (especially if you don't + know all the data you want to send to standard input at the + beginning), use the start() function. + + If you use start() you can write to the program's standard input + using writeToStdin() and you can close the standard input with + closeStdin(). The wroteToStdin() signal is emitted if the data + sent to standard input has been written. You can read from the + program's standard output using readStdout() or readLineStdout(). + These functions return an empty QByteArray if there is no data to + read. The readyReadStdout() signal is emitted when there is data + available to be read from standard output. Standard error has a + set of functions that correspond to the standard output functions, + i.e. readStderr(), readLineStderr() and readyReadStderr(). + + If you use one of the launch() functions the data you pass will be + sent to the program's standard input which will be closed once all + the data has been written. You should \e not use writeToStdin() or + closeStdin() if you use launch(). If you need to send data to the + program's standard input after it has started running use start() + instead of launch(). + + Both start() and launch() can accept a string list of strings each + of which has the format, key=value, where the keys are the names + of environment variables. + + You can test to see if a program is running with isRunning(). The + program's process identifier is available from + processIdentifier(). If you want to terminate a running program + use tryTerminate(), but note that the program may ignore this. If + you \e really want to terminate the program, without it having any + chance to clean up, you can use kill(). + + Although you may need quotes for a file named on the command line + (e.g. if it contains spaces) you shouldn't use extra quotes for + arguments passed to addArgument() or setArguments(). + + The readyReadStdout() signal is emitted when there is new data on + standard output. This happens asynchronously: you don't know if + more data will arrive later. + + In the above example you could connect the processExited() signal + to the slot UicManager::readFromStdout() instead. If you do so, + you will be certain that all the data is available when the slot + is called. On the other hand, you must wait until the process has + finished before doing any processing. + + Note that if you are expecting a lot of output from the process, + you may hit platform-dependent limits to the pipe buffer size. The + solution is to make sure you connect to the output, e.g. the + readyReadStdout() and readyReadStderr() signals and read the data + as soon as it becomes available. + + Please note that Q3Process does not emulate a shell. This means that + Q3Process does not do any expansion of arguments: a '*' is passed as a '*' + to the program and is \e not replaced by all the files, a '$HOME' is also + passed literally and is \e not replaced by the environment variable HOME + and the special characters for IO redirection ('>', '|', etc.) are also + passed literally and do \e not have the special meaning as they have in a + shell. + + Also note that Q3Process does not emulate a terminal. This means that + certain programs which need direct terminal control, do not work as + expected with Q3Process. Such programs include console email programs (like + pine and mutt) but also programs which require the user to enter a password + (like su and ssh). + + \section1 Notes for Windows users + + Some Windows commands, for example, \c dir, are not provided by + separate applications, but by the command interpreter. + If you attempt to use Q3Process to execute these commands directly + it won't work. One possible solution is to execute the command + interpreter itself (\c cmd.exe on some Windows systems), and ask + the interpreter to execute the desired command. + + Under Windows there are certain problems starting 16-bit applications + and capturing their output. Microsoft recommends using an intermediate + application to start 16-bit applications. + + \sa Q3Socket +*/ + +/*! + \enum Q3Process::Communication + + This enum type defines the communication channels connected to the + process. + + \value Stdin Data can be written to the process's standard input. + + \value Stdout Data can be read from the process's standard + output. + + \value Stderr Data can be read from the process's standard error. + + \value DupStderr Both the process's standard error output \e and + its standard output are written to its standard output. (Like + Unix's dup2().) This means that nothing is sent to the standard + error output. This is especially useful if your application + requires that the output on standard output and on standard error + must be read in the same order that they are produced. This is a + flag, so to activate it you must pass \c{Stdout|Stderr|DupStderr}, + or \c{Stdin|Stdout|Stderr|DupStderr} if you want to provide input, + to the setCommunication() call. + + \sa setCommunication() communication() +*/ + +/*! + Constructs a Q3Process object. The \a parent and \a name parameters + are passed to the QObject constructor. + + \sa setArguments() addArgument() start() +*/ +Q3Process::Q3Process( QObject *parent, const char *name ) + : QObject( parent, name ), ioRedirection( false ), notifyOnExit( false ), + wroteToStdinConnected( false ), + readStdoutCalled( false ), readStderrCalled( false ), + comms( Stdin|Stdout|Stderr ) +{ + init(); +} + +/*! + Constructs a Q3Process with \a arg0 as the command to be executed. + The \a parent and \a name parameters are passed to the QObject + constructor. + + The process is not started. You must call start() or launch() to + start the process. + + \sa setArguments() addArgument() start() +*/ +Q3Process::Q3Process( const QString& arg0, QObject *parent, const char *name ) + : QObject( parent, name ), ioRedirection( false ), notifyOnExit( false ), + wroteToStdinConnected( false ), + readStdoutCalled( false ), readStderrCalled( false ), + comms( Stdin|Stdout|Stderr ) +{ + init(); + addArgument( arg0 ); +} + +/*! + Constructs a Q3Process with \a args as the arguments of the + process. The first element in the list is the command to be + executed. The other elements in the list are the arguments to this + command. The \a parent and \a name parameters are passed to the + QObject constructor. + + The process is not started. You must call start() or launch() to + start the process. + + \sa setArguments() addArgument() start() +*/ +Q3Process::Q3Process( const QStringList& args, QObject *parent, const char *name ) + : QObject( parent, name ), ioRedirection( false ), notifyOnExit( false ), + wroteToStdinConnected( false ), + readStdoutCalled( false ), readStderrCalled( false ), + comms( Stdin|Stdout|Stderr ) +{ + init(); + setArguments( args ); +} + +/*! + \fn Q3Process::~Q3Process() + + Destroys the instance. + + If the process is running, it is <b>not</b> terminated! The + standard input, standard output and standard error of the process + are closed. + + You can connect the destroyed() signal to the kill() slot, if you + want the process to be terminated automatically when the instance + is destroyed. + + \sa tryTerminate() kill() +*/ + +/*! + Returns the list of arguments that are set for the process. + Arguments can be specified with the constructor or with the + functions setArguments() and addArgument(). + + Note that if you want to iterate over the list, you should iterate + over a copy, e.g. + \snippet doc/src/snippets/code/src_qt3support_other_q3process.cpp 0 + + \sa setArguments() addArgument() +*/ +QStringList Q3Process::arguments() const +{ + return _arguments; +} + +/*! + Clears the list of arguments that are set for the process. + + \sa setArguments() addArgument() +*/ +void Q3Process::clearArguments() +{ + _arguments.clear(); +} + +/*! + Sets \a args as the arguments for the process. The first element + in the list is the command to be executed. The other elements in + the list are the arguments to the command. Any previous arguments + are deleted. + + Q3Process does not perform argument substitutions; for example, if you + specify "*" or "$DISPLAY", these values are passed to the process + literally. If you want to have the same behavior as the shell + provides, you must do the substitutions yourself; i.e. instead of + specifying a "*" you must specify the list of all the filenames in + the current directory, and instead of "$DISPLAY" you must specify + the value of the environment variable \c DISPLAY. + + Note for Windows users. The standard Windows shells, e.g. \c + command.com and \c cmd.exe, do not perform file globbing, i.e. + they do not convert a "*" on the command line into a list of files + in the current directory. For this reason most Windows + applications implement their own file globbing, and as a result of + this, specifying an argument of "*" for a Windows application is + likely to result in the application performing a file glob and + ending up with a list of filenames. + + \sa arguments() addArgument() +*/ +void Q3Process::setArguments( const QStringList& args ) +{ + _arguments = args; +} + +/*! + Adds \a arg to the end of the list of arguments. + + The first element in the list of arguments is the command to be + executed; the following elements are the command's arguments. + + \sa arguments() setArguments() +*/ +void Q3Process::addArgument( const QString& arg ) +{ + _arguments.append( arg ); +} + +#ifndef QT_NO_DIR +/*! + Returns the working directory that was set with + setWorkingDirectory(), or the current directory if none has been + explicitly set. + + \sa setWorkingDirectory() QDir::current() +*/ +QDir Q3Process::workingDirectory() const +{ + return workingDir; +} + +/*! + Sets \a dir as the working directory for processes. This does not + affect running processes; only processes that are started + afterwards are affected. + + Setting the working directory is especially useful for processes + that try to access files with relative paths. + + \sa workingDirectory() start() +*/ +void Q3Process::setWorkingDirectory( const QDir& dir ) +{ + workingDir = dir; +} +#endif //QT_NO_DIR + +/*! + Returns the communication required with the process, i.e. some + combination of the \c Communication flags. + + \sa setCommunication() +*/ +int Q3Process::communication() const +{ + return comms; +} + +/*! + Sets \a commFlags as the communication required with the process. + + \a commFlags is a bitwise OR of the flags defined by the \c + Communication enum. + + The default is \c{Stdin|Stdout|Stderr}. + + \sa communication() +*/ +void Q3Process::setCommunication( int commFlags ) +{ + comms = commFlags; +} + +/*! + Returns true if the process has exited normally; otherwise returns + false. This implies that this function returns false if the + process is still running. + + \sa isRunning() exitStatus() processExited() +*/ +bool Q3Process::normalExit() const +{ + // isRunning() has the side effect that it determines the exit status! + if ( isRunning() ) + return false; + else + return exitNormal; +} + +/*! + Returns the exit status of the process or 0 if the process is + still running. This function returns immediately and does not wait + until the process is finished. + + If normalExit() is false (e.g. if the program was killed or + crashed), this function returns 0, so you should check the return + value of normalExit() before relying on this value. + + \sa normalExit() processExited() +*/ +int Q3Process::exitStatus() const +{ + // isRunning() has the side effect that it determines the exit status! + if ( isRunning() ) + return 0; + else + return exitStat; +} + + +/*! + Reads the data that the process has written to standard output. + When new data is written to standard output, the class emits the + signal readyReadStdout(). + + If there is no data to read, this function returns a QByteArray of + size 0: it does not wait until there is something to read. + + \sa readyReadStdout() readLineStdout() readStderr() writeToStdin() +*/ +QByteArray Q3Process::readStdout() +{ + if ( readStdoutCalled ) { + return QByteArray(); + } + readStdoutCalled = true; + Q3Membuf *buf = membufStdout(); + readStdoutCalled = false; + + return buf->readAll(); +} + +/*! + Reads the data that the process has written to standard error. + When new data is written to standard error, the class emits the + signal readyReadStderr(). + + If there is no data to read, this function returns a QByteArray of + size 0: it does not wait until there is something to read. + + \sa readyReadStderr() readLineStderr() readStdout() writeToStdin() +*/ +QByteArray Q3Process::readStderr() +{ + if ( readStderrCalled ) { + return QByteArray(); + } + readStderrCalled = true; + Q3Membuf *buf = membufStderr(); + readStderrCalled = false; + + return buf->readAll(); +} + +/*! + Reads a line of text from standard output, excluding any trailing + newline or carriage return characters, and returns it. Returns + an empty string if canReadLineStdout() returns false. + + By default, the text is interpreted to be in Latin-1 encoding. If you need + other codecs, you can set a different codec with + QTextCodec::setCodecForCStrings(). + + \sa canReadLineStdout() readyReadStdout() readStdout() readLineStderr() +*/ +QString Q3Process::readLineStdout() +{ + QByteArray a( 256 ); + Q3Membuf *buf = membufStdout(); + if ( !buf->scanNewline( &a ) ) { + if ( !canReadLineStdout() ) + return QString(); + + if ( !buf->scanNewline( &a ) ) + return QString( QLatin1String(buf->readAll()) ); + } + + uint size = a.size(); + buf->consumeBytes( size, 0 ); + + // get rid of terminating \n or \r\n + if ( size>0 && a.at( size - 1 ) == '\n' ) { + if ( size>1 && a.at( size - 2 ) == '\r' ) + a.chop(2); + else + a.chop(1); + } + return QString(QString::fromLatin1(a.constData())); +} + +/*! + Reads a line of text from standard error, excluding any trailing + newline or carriage return characters and returns it. Returns + an empty string if canReadLineStderr() returns false. + + By default, the text is interpreted to be in Latin-1 encoding. If you need + other codecs, you can set a different codec with + QTextCodec::setCodecForCStrings(). + + \sa canReadLineStderr() readyReadStderr() readStderr() readLineStdout() +*/ +QString Q3Process::readLineStderr() +{ + QByteArray a( 256 ); + Q3Membuf *buf = membufStderr(); + if ( !buf->scanNewline( &a ) ) { + if ( !canReadLineStderr() ) + return QString(); + + if ( !buf->scanNewline( &a ) ) + return QString( QString::fromLatin1( buf->readAll().constData() ) ); + } + + uint size = a.size(); + buf->consumeBytes( size, 0 ); + + // get rid of terminating \n or \r\n + if ( size>0 && a.at( size - 1 ) == '\n' ) { + if ( size>1 && a.at( size - 2 ) == '\r' ) + a.chop(2); + else + a.chop(1); + } + return QString( QString::fromLatin1( a.constData() ) ); +} + +/*! + \fn bool Q3Process::start( QStringList *env ) + + Tries to run a process for the command and arguments that were + specified with setArguments(), addArgument() or that were + specified in the constructor. The command is searched for in the + path for executable programs; you can also use an absolute path in + the command itself. + + If \a env is null, then the process is started with the same + environment as the starting process. If \a env is non-null, then + the values in the stringlist are interpreted as environment + setttings of the form \c {key=value} and the process is started in + these environment settings. For convenience, there is a small + exception to this rule: under Unix, if \a env does not contain any + settings for the environment variable \c LD_LIBRARY_PATH, then + this variable is inherited from the starting process; under + Windows the same applies for the environment variable \c PATH. + + Returns true if the process could be started; otherwise returns + false. + + You can write data to the process's standard input with + writeToStdin(). You can close standard input with closeStdin() and + you can terminate the process with tryTerminate(), or with kill(). + + You can call this function even if you've used this instance to + create a another process which is still running. In such cases, + Q3Process closes the old process's standard input and deletes + pending data, i.e., you lose all control over the old process, but + the old process is not terminated. This applies also if the + process could not be started. (On operating systems that have + zombie processes, Qt will also wait() on the old process.) + + \sa launch() closeStdin() +*/ + +/*! + \fn void Q3Process::tryTerminate() const + + Asks the process to terminate. Processes can ignore this if they + wish. If you want to be certain that the process really + terminates, you can use kill() instead. + + The slot returns immediately: it does not wait until the process + has finished. When the process terminates, the processExited() + signal is emitted. + + \sa kill() processExited() +*/ + +/*! + \fn void Q3Process::kill() const + + Terminates the process. This is not a safe way to end a process + since the process will not be able to do any cleanup. + tryTerminate() is safer, but processes can ignore a + tryTerminate(). + + The nice way to end a process and to be sure that it is finished, + is to do something like this: + \snippet doc/src/snippets/code/src_qt3support_other_q3process_unix.cpp 0 + + This tries to terminate the process the nice way. If the process + is still running after 5 seconds, it terminates the process the + hard way. The timeout should be chosen depending on the time the + process needs to do all its cleanup: use a higher value if the + process is likely to do a lot of computation or I/O on cleanup. + + The slot returns immediately: it does not wait until the process + has finished. When the process terminates, the processExited() + signal is emitted. + + \sa tryTerminate() processExited() +*/ + +/*! + \fn bool Q3Process::isRunning() const + + Returns true if the process is running; otherwise returns false. + + \sa normalExit() exitStatus() processExited() +*/ + +/*! + \fn bool Q3Process::canReadLineStdout() const + + Returns true if it's possible to read an entire line of text from + standard output at this time; otherwise returns false. + + \sa readLineStdout() canReadLineStderr() +*/ + +/*! + \fn bool Q3Process::canReadLineStderr() const + + Returns true if it's possible to read an entire line of text from + standard error at this time; otherwise returns false. + + \sa readLineStderr() canReadLineStdout() +*/ + +/*! + \fn void Q3Process::writeToStdin( const QByteArray& buf ) + + Writes the data \a buf to the process's standard input. The + process may or may not read this data. + + This function returns immediately; the Q3Process class might write + the data at a later point (you must enter the event loop for this + to occur). When all the data is written to the process, the signal + wroteToStdin() is emitted. This does not mean that the process + actually read the data, since this class only detects when it was + able to write the data to the operating system. + + \sa wroteToStdin() closeStdin() readStdout() readStderr() +*/ + +/*! + \fn void Q3Process::closeStdin() + + Closes the process's standard input. + + This function also deletes any pending data that has not been + written to standard input. + + \sa wroteToStdin() +*/ + +/*! + \fn Q3Process::PID Q3Process::processIdentifier() + + Returns platform dependent information about the process. This can + be used together with platform specific system calls. + + Under Unix the return value is the PID of the process, or -1 if no + process belongs to this object. + + Under Windows it is a pointer to the \c PROCESS_INFORMATION + struct, or 0 if no process is belongs to this object. + + Use of this function's return value is likely to be non-portable. +*/ + +/*! + \fn void Q3Process::launchFinished() + + This signal is emitted when the process was started with launch(). + If the start was successful, this signal is emitted after all the + data has been written to standard input. If the start failed, then + this signal is emitted immediately. + + This signal is especially useful if you want to know when you can + safely delete the Q3Process object when you are not interested in + reading from standard output or standard error. + + \sa launch() QObject::deleteLater() +*/ + +/*! + Runs the process and writes the data \a buf to the process's + standard input. If all the data is written to standard input, + standard input is closed. The command is searched for in the path + for executable programs; you can also use an absolute path in the + command itself. + + If \a env is null, then the process is started with the same + environment as the starting process. If \a env is non-null, then + the values in the string list are interpreted as environment + setttings of the form \c {key=value} and the process is started + with these environment settings. For convenience, there is a small + exception to this rule under Unix: if \a env does not contain any + settings for the environment variable \c LD_LIBRARY_PATH, then + this variable is inherited from the starting process. + + Returns true if the process could be started; otherwise returns + false. + + Note that you should not use the slots writeToStdin() and + closeStdin() on processes started with launch(), since the result + is not well-defined. If you need these slots, use start() instead. + + The process may or may not read the \a buf data sent to its + standard input. + + You can call this function even when a process that was started + with this instance is still running. Be aware that if you do this + the standard input of the process that was launched first will be + closed, with any pending data being deleted, and the process will + be left to run out of your control. Similarly, if the process + could not be started the standard input will be closed and the + pending data deleted. (On operating systems that have zombie + processes, Qt will also wait() on the old process.) + + The object emits the signal launchFinished() when this function + call is finished. If the start was successful, this signal is + emitted after all the data has been written to standard input. If + the start failed, then this signal is emitted immediately. + + \sa start() launchFinished() +*/ +bool Q3Process::launch( const QByteArray& buf, QStringList *env ) +{ + if ( start( env ) ) { + if ( !buf.isEmpty() ) { + connect( this, SIGNAL(wroteToStdin()), + this, SLOT(closeStdinLaunch()) ); + writeToStdin( buf ); + } else { + closeStdin(); + emit launchFinished(); + } + return true; + } else { + emit launchFinished(); + return false; + } +} + +/*! + \overload + + The data \a buf is written to standard input with writeToStdin() + using the QString::local8Bit() representation of the strings. +*/ +bool Q3Process::launch( const QString& buf, QStringList *env ) +{ + if ( start( env ) ) { + if ( !buf.isEmpty() ) { + connect( this, SIGNAL(wroteToStdin()), + this, SLOT(closeStdinLaunch()) ); + writeToStdin( buf ); + } else { + closeStdin(); + emit launchFinished(); + } + return true; + } else { + emit launchFinished(); + return false; + } +} + +/* + This private slot is used by the launch() functions to close standard input. +*/ +void Q3Process::closeStdinLaunch() +{ + disconnect( this, SIGNAL(wroteToStdin()), + this, SLOT(closeStdinLaunch()) ); + closeStdin(); + emit launchFinished(); +} + + +/*! + \fn void Q3Process::readyReadStdout() + + This signal is emitted when the process has written data to + standard output. You can read the data with readStdout(). + + Note that this signal is only emitted when there is new data and + not when there is old, but unread data. In the slot connected to + this signal, you should always read everything that is available + at that moment to make sure that you don't lose any data. + + \sa readStdout() readLineStdout() readyReadStderr() +*/ + +/*! + \fn void Q3Process::readyReadStderr() + + This signal is emitted when the process has written data to + standard error. You can read the data with readStderr(). + + Note that this signal is only emitted when there is new data and + not when there is old, but unread data. In the slot connected to + this signal, you should always read everything that is available + at that moment to make sure that you don't lose any data. + + \sa readStderr() readLineStderr() readyReadStdout() +*/ + +/*! + \fn void Q3Process::processExited() + + This signal is emitted when the process has exited. + + \sa isRunning() normalExit() exitStatus() start() launch() +*/ + +/*! + \fn void Q3Process::wroteToStdin() + + This signal is emitted if the data sent to standard input (via + writeToStdin()) was actually written to the process. This does not + imply that the process really read the data, since this class only + detects when it was able to write the data to the operating + system. But it is now safe to close standard input without losing + pending data. + + \sa writeToStdin() closeStdin() +*/ + + +/*! + \overload + + The string \a buf is handled as text using the + QString::local8Bit() representation. +*/ +void Q3Process::writeToStdin( const QString& buf ) +{ + QByteArray tmp = buf.local8Bit(); + tmp.resize( buf.length() ); + writeToStdin( tmp ); +} + + +/* + * Under Windows the implementation is not so nice: it is not that easy to + * detect when one of the signals should be emitted; therefore there are some + * timers that query the information. + * To keep it a little efficient, use the timers only when they are needed. + * They are needed, if you are interested in the signals. So use + * connectNotify() and disconnectNotify() to keep track of your interest. + */ +/*! \reimp +*/ +void Q3Process::connectNotify( const char * signal ) +{ +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::connectNotify(): signal %s has been connected", signal ); +#endif + if ( !ioRedirection ) + if ( qstrcmp( signal, SIGNAL(readyReadStdout()) )==0 || + qstrcmp( signal, SIGNAL(readyReadStderr()) )==0 + ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::connectNotify(): set ioRedirection to true" ); +#endif + setIoRedirection( true ); + return; + } + if ( !notifyOnExit && qstrcmp( signal, SIGNAL(processExited()) )==0 ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::connectNotify(): set notifyOnExit to true" ); +#endif + setNotifyOnExit( true ); + return; + } + if ( !wroteToStdinConnected && qstrcmp( signal, SIGNAL(wroteToStdin()) )==0 ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::connectNotify(): set wroteToStdinConnected to true" ); +#endif + setWroteStdinConnected( true ); + return; + } +} + +/*! \reimp +*/ +void Q3Process::disconnectNotify( const char * ) +{ + if ( ioRedirection && + receivers( SIGNAL(readyReadStdout()) ) ==0 && + receivers( SIGNAL(readyReadStderr()) ) ==0 + ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::disconnectNotify(): set ioRedirection to false" ); +#endif + setIoRedirection( false ); + } + if ( notifyOnExit && receivers( SIGNAL(processExited()) ) == 0 ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::disconnectNotify(): set notifyOnExit to false" ); +#endif + setNotifyOnExit( false ); + } + if ( wroteToStdinConnected && receivers( SIGNAL(wroteToStdin()) ) == 0 ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::disconnectNotify(): set wroteToStdinConnected to false" ); +#endif + setWroteStdinConnected( false ); + } +} + +QT_END_NAMESPACE + +#endif // QT_NO_PROCESS diff --git a/src/qt3support/other/q3process.h b/src/qt3support/other/q3process.h new file mode 100644 index 0000000..ac28390 --- /dev/null +++ b/src/qt3support/other/q3process.h @@ -0,0 +1,186 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef Q3PROCESS_H +#define Q3PROCESS_H + +#include <QtCore/qobject.h> +#include <QtCore/qstringlist.h> +#include <QtCore/qdir.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +#ifndef QT_NO_PROCESS + +class Q3ProcessPrivate; +class Q3Membuf; + +class Q_COMPAT_EXPORT Q3Process : public QObject +{ + Q_OBJECT +public: + Q3Process( QObject *parent=0, const char *name=0 ); + Q3Process( const QString& arg0, QObject *parent=0, const char *name=0 ); + Q3Process( const QStringList& args, QObject *parent=0, const char *name=0 ); + ~Q3Process(); + + // set and get the arguments and working directory + QStringList arguments() const; + void clearArguments(); + virtual void setArguments( const QStringList& args ); + virtual void addArgument( const QString& arg ); +#ifndef QT_NO_DIR + QDir workingDirectory() const; + virtual void setWorkingDirectory( const QDir& dir ); +#endif + + // set and get the comms wanted + enum Communication { Stdin=0x01, Stdout=0x02, Stderr=0x04, DupStderr=0x08 }; + void setCommunication( int c ); + int communication() const; + + // start the execution + virtual bool start( QStringList *env=0 ); + virtual bool launch( const QString& buf, QStringList *env=0 ); + virtual bool launch( const QByteArray& buf, QStringList *env=0 ); + + // inquire the status + bool isRunning() const; + bool normalExit() const; + int exitStatus() const; + + // reading + virtual QByteArray readStdout(); + virtual QByteArray readStderr(); + bool canReadLineStdout() const; + bool canReadLineStderr() const; + virtual QString readLineStdout(); + virtual QString readLineStderr(); + + // get platform dependent process information +#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE) + typedef void* PID; +#else + typedef Q_LONG PID; +#endif + PID processIdentifier(); + + void flushStdin(); + +Q_SIGNALS: + void readyReadStdout(); + void readyReadStderr(); + void processExited(); + void wroteToStdin(); + void launchFinished(); + +public Q_SLOTS: + // end the execution + void tryTerminate() const; + void kill() const; + + // input + virtual void writeToStdin( const QByteArray& buf ); + virtual void writeToStdin( const QString& buf ); + virtual void closeStdin(); + +protected: // ### or private? + void connectNotify( const char * signal ); + void disconnectNotify( const char * signal ); +private: + void setIoRedirection( bool value ); + void setNotifyOnExit( bool value ); + void setWroteStdinConnected( bool value ); + + void init(); + void reset(); +#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE) + uint readStddev( Qt::HANDLE dev, char *buf, uint bytes ); +#endif + Q3Membuf* membufStdout(); + Q3Membuf* membufStderr(); + +private Q_SLOTS: + void socketRead( int fd ); + void socketWrite( int fd ); + void timeout(); + void closeStdinLaunch(); + +private: + Q3ProcessPrivate *d; +#ifndef QT_NO_DIR + QDir workingDir; +#endif + QStringList _arguments; + + int exitStat; // exit status + bool exitNormal; // normal exit? + bool ioRedirection; // automatically set be (dis)connectNotify + bool notifyOnExit; // automatically set be (dis)connectNotify + bool wroteToStdinConnected; // automatically set be (dis)connectNotify + + bool readStdoutCalled; + bool readStderrCalled; + int comms; + + friend class Q3ProcessPrivate; +#if defined(Q_OS_UNIX) + friend class Q3ProcessManager; + friend class QProc; +#endif + +#if defined(Q_DISABLE_COPY) // Disabled copy constructor and operator= + Q3Process( const Q3Process & ); + Q3Process &operator=( const Q3Process & ); +#endif +}; + +#endif // QT_NO_PROCESS + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // Q3PROCESS_H diff --git a/src/qt3support/other/q3process_unix.cpp b/src/qt3support/other/q3process_unix.cpp new file mode 100644 index 0000000..098c581 --- /dev/null +++ b/src/qt3support/other/q3process_unix.cpp @@ -0,0 +1,1282 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qplatformdefs.h" + +// Solaris redefines connect -> __xnet_connect with _XOPEN_SOURCE_EXTENDED. +#if defined(connect) +#undef connect +#endif + +#include "q3process.h" + +#ifndef QT_NO_PROCESS + +#include "qapplication.h" +#include "q3cstring.h" +#include "q3ptrqueue.h" +#include "q3ptrlist.h" +#include "qsocketnotifier.h" +#include "qtimer.h" +#include "q3cleanuphandler.h" +#include "qregexp.h" +#include "private/q3membuf_p.h" +#include "private/qobject_p.h" + +#include <stdlib.h> +#include <errno.h> +#include <sys/types.h> + +QT_BEGIN_NAMESPACE + +#ifdef __MIPSEL__ +# ifndef SOCK_DGRAM +# define SOCK_DGRAM 1 +# endif +# ifndef SOCK_STREAM +# define SOCK_STREAM 2 +# endif +#endif + +//#define QT_Q3PROCESS_DEBUG + + +#ifdef Q_C_CALLBACKS +extern "C" { +#endif // Q_C_CALLBACKS + + static QT_SIGNAL_RETTYPE qt_C_sigchldHnd(QT_SIGNAL_ARGS); + +#ifdef Q_C_CALLBACKS +} +#endif // Q_C_CALLBACKS + + +class QProc; +class Q3ProcessManager; +class Q3ProcessPrivate +{ +public: + Q3ProcessPrivate(); + ~Q3ProcessPrivate(); + + void closeOpenSocketsForChild(); + void newProc( pid_t pid, Q3Process *process ); + + Q3Membuf bufStdout; + Q3Membuf bufStderr; + + Q3PtrQueue<QByteArray> stdinBuf; + + QSocketNotifier *notifierStdin; + QSocketNotifier *notifierStdout; + QSocketNotifier *notifierStderr; + + ssize_t stdinBufRead; + QProc *proc; + + bool exitValuesCalculated; + bool socketReadCalled; + + static Q3ProcessManager *procManager; +}; + + +/*********************************************************************** + * + * QProc + * + **********************************************************************/ +/* + The class Q3Process does not necessarily map exactly to the running + child processes: if the process is finished, the Q3Process class may still be + there; furthermore a user can use Q3Process to start more than one process. + + The helper-class QProc has the semantics that one instance of this class maps + directly to a running child process. +*/ +class QProc +{ +public: + QProc( pid_t p, Q3Process *proc=0 ) : pid(p), process(proc) + { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "QProc: Constructor for pid %d and Q3Process %p", pid, process ); +#endif + socketStdin = 0; + socketStdout = 0; + socketStderr = 0; + } + ~QProc() + { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "QProc: Destructor for pid %d and Q3Process %p", pid, process ); +#endif + if ( process ) { + if ( process->d->notifierStdin ) + process->d->notifierStdin->setEnabled( false ); + if ( process->d->notifierStdout ) + process->d->notifierStdout->setEnabled( false ); + if ( process->d->notifierStderr ) + process->d->notifierStderr->setEnabled( false ); + process->d->proc = 0; + } + if( socketStdin ) + ::close( socketStdin ); + if( socketStdout ) + ::close( socketStdout ); + if( socketStderr ) + ::close( socketStderr ); + } + + pid_t pid; + int socketStdin; + int socketStdout; + int socketStderr; + Q3Process *process; +}; + +/*********************************************************************** + * + * Q3ProcessManager + * + **********************************************************************/ +class Q3ProcessManager : public QObject +{ + Q_OBJECT + +public: + Q3ProcessManager(); + ~Q3ProcessManager(); + + void append( QProc *p ); + void remove( QProc *p ); + + void cleanup(); + +public slots: + void removeMe(); + void sigchldHnd( int ); + +public: + struct sigaction oldactChld; + struct sigaction oldactPipe; + Q3PtrList<QProc> *procList; + int sigchldFd[2]; + +private: + QSocketNotifier *sn; +}; + +static void q3process_cleanup() +{ + delete Q3ProcessPrivate::procManager; + Q3ProcessPrivate::procManager = 0; +} + +#ifdef Q_OS_QNX6 +#define BAILOUT close(tmpSocket);close(socketFD[1]);return -1; +int qnx6SocketPairReplacement (int socketFD[2]) { + int tmpSocket; + tmpSocket = socket (AF_INET, SOCK_STREAM, 0); + if (tmpSocket == -1) + return -1; + socketFD[1] = socket(AF_INET, SOCK_STREAM, 0); + if (socketFD[1] == -1) { BAILOUT }; + + sockaddr_in ipAddr; + memset(&ipAddr, 0, sizeof(ipAddr)); + ipAddr.sin_family = AF_INET; + ipAddr.sin_addr.s_addr = INADDR_ANY; + + int socketOptions = 1; + setsockopt(tmpSocket, SOL_SOCKET, SO_REUSEADDR, &socketOptions, sizeof(int)); + + bool found = false; + for (int socketIP = 2000; (socketIP < 2500) && !(found); socketIP++) { + ipAddr.sin_port = htons(socketIP); + if (bind(tmpSocket, (struct sockaddr *)&ipAddr, sizeof(ipAddr))) + found = true; + } + + if (listen(tmpSocket, 5)) { BAILOUT }; + + // Select non-blocking mode + int originalFlags = fcntl(socketFD[1], F_GETFL, 0); + fcntl(socketFD[1], F_SETFL, originalFlags | O_NONBLOCK); + + // Request connection + if (connect(socketFD[1], (struct sockaddr*)&ipAddr, sizeof(ipAddr))) + if (errno != EINPROGRESS) { BAILOUT }; + + // Accept connection + socketFD[0] = accept(tmpSocket, (struct sockaddr *)NULL, (size_t *)NULL); + if(socketFD[0] == -1) { BAILOUT }; + + // We're done + close(tmpSocket); + + // Restore original flags , ie return to blocking + fcntl(socketFD[1], F_SETFL, originalFlags); + return 0; +} +#undef BAILOUT +#endif + +Q3ProcessManager::Q3ProcessManager() : sn(0) +{ + procList = new Q3PtrList<QProc>; + procList->setAutoDelete( true ); + + // The SIGCHLD handler writes to a socket to tell the manager that + // something happened. This is done to get the processing in sync with the + // event reporting. +#ifndef Q_OS_QNX6 + if ( ::socketpair( AF_UNIX, SOCK_STREAM, 0, sigchldFd ) ) { +#else + if ( qnx6SocketPairReplacement (sigchldFd) ) { +#endif + sigchldFd[0] = 0; + sigchldFd[1] = 0; + } else { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager: install socket notifier (%d)", sigchldFd[1] ); +#endif + sn = new QSocketNotifier( sigchldFd[1], + QSocketNotifier::Read, this ); + connect( sn, SIGNAL(activated(int)), + this, SLOT(sigchldHnd(int)) ); + sn->setEnabled( true ); + } + + // install a SIGCHLD handler and ignore SIGPIPE + struct sigaction act; + +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager: install a SIGCHLD handler" ); +#endif + act.sa_handler = qt_C_sigchldHnd; + sigemptyset( &(act.sa_mask) ); + sigaddset( &(act.sa_mask), SIGCHLD ); + act.sa_flags = SA_NOCLDSTOP; +#if defined(SA_RESTART) + act.sa_flags |= SA_RESTART; +#endif + if ( sigaction( SIGCHLD, &act, &oldactChld ) != 0 ) + qWarning( "Error installing SIGCHLD handler" ); + +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager: install a SIGPIPE handler (SIG_IGN)" ); +#endif + act.sa_handler = QT_SIGNAL_IGNORE; + sigemptyset( &(act.sa_mask) ); + sigaddset( &(act.sa_mask), SIGPIPE ); + act.sa_flags = 0; + if ( sigaction( SIGPIPE, &act, &oldactPipe ) != 0 ) + qWarning( "Error installing SIGPIPE handler" ); +} + +Q3ProcessManager::~Q3ProcessManager() +{ + delete procList; + + if ( sigchldFd[0] != 0 ) + ::close( sigchldFd[0] ); + if ( sigchldFd[1] != 0 ) + ::close( sigchldFd[1] ); + + // restore SIGCHLD handler +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager: restore old sigchild handler" ); +#endif + if ( sigaction( SIGCHLD, &oldactChld, 0 ) != 0 ) + qWarning( "Error restoring SIGCHLD handler" ); + +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager: restore old sigpipe handler" ); +#endif + if ( sigaction( SIGPIPE, &oldactPipe, 0 ) != 0 ) + qWarning( "Error restoring SIGPIPE handler" ); +} + +void Q3ProcessManager::append( QProc *p ) +{ + procList->append( p ); +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager: append process (procList.count(): %d)", procList->count() ); +#endif +} + +void Q3ProcessManager::remove( QProc *p ) +{ + procList->remove( p ); +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager: remove process (procList.count(): %d)", procList->count() ); +#endif + cleanup(); +} + +void Q3ProcessManager::cleanup() +{ + if ( procList->count() == 0 ) { + QTimer::singleShot( 0, this, SLOT(removeMe()) ); + } +} + +void Q3ProcessManager::removeMe() +{ + if ( procList->count() == 0 ) { + qRemovePostRoutine(q3process_cleanup); + Q3ProcessPrivate::procManager = 0; + delete this; + } +} + +void Q3ProcessManager::sigchldHnd( int fd ) +{ + // Disable the socket notifier to make sure that this function is not + // called recursively -- this can happen, if you enter the event loop in + // the slot connected to the processExited() signal (e.g. by showing a + // modal dialog) and there are more than one process which exited in the + // meantime. + if ( sn ) { + if ( !sn->isEnabled() ) + return; + sn->setEnabled( false ); + } + + char tmp; + ::read( fd, &tmp, sizeof(tmp) ); +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager::sigchldHnd()" ); +#endif + QProc *proc; + Q3Process *process; + bool removeProc; + proc = procList->first(); + while ( proc != 0 ) { + removeProc = false; + process = proc->process; + if ( process != 0 ) { + if ( !process->isRunning() ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager::sigchldHnd() (PID: %d): process exited (Q3Process available)", proc->pid ); +#endif + /* + Apparently, there is not consistency among different + operating systems on how to use FIONREAD. + + FreeBSD, Linux and Solaris all expect the 3rd + argument to ioctl() to be an int, which is normally + 32-bit even on 64-bit machines. + + IRIX, on the other hand, expects a size_t, which is + 64-bit on 64-bit machines. + + So, the solution is to use size_t initialized to + zero to make sure all bits are set to zero, + preventing underflow with the FreeBSD/Linux/Solaris + ioctls. + */ + size_t nbytes = 0; + // read pending data + if ( proc->socketStdout && ::ioctl(proc->socketStdout, FIONREAD, (char*)&nbytes)==0 && nbytes>0 ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager::sigchldHnd() (PID: %d): reading %d bytes of pending data on stdout", proc->pid, nbytes ); +#endif + process->socketRead( proc->socketStdout ); + } + nbytes = 0; + if ( proc->socketStderr && ::ioctl(proc->socketStderr, FIONREAD, (char*)&nbytes)==0 && nbytes>0 ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager::sigchldHnd() (PID: %d): reading %d bytes of pending data on stderr", proc->pid, nbytes ); +#endif + process->socketRead( proc->socketStderr ); + } + // close filedescriptors if open, and disable the + // socket notifiers + if ( proc->socketStdout ) { + ::close( proc->socketStdout ); + proc->socketStdout = 0; + if (process->d->notifierStdout) + process->d->notifierStdout->setEnabled(false); + } + if ( proc->socketStderr ) { + ::close( proc->socketStderr ); + proc->socketStderr = 0; + if (process->d->notifierStderr) + process->d->notifierStderr->setEnabled(false); + } + + if ( process->notifyOnExit ) + emit process->processExited(); + + removeProc = true; + } + } else { + int status; + if ( ::waitpid( proc->pid, &status, WNOHANG ) == proc->pid ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessManager::sigchldHnd() (PID: %d): process exited (Q3Process not available)", proc->pid ); +#endif + removeProc = true; + } + } + if ( removeProc ) { + QProc *oldproc = proc; + proc = procList->next(); + remove( oldproc ); + } else { + proc = procList->next(); + } + } + if ( sn ) + sn->setEnabled( true ); +} + +QT_BEGIN_INCLUDE_NAMESPACE +#include "q3process_unix.moc" +QT_END_INCLUDE_NAMESPACE + + +/*********************************************************************** + * + * Q3ProcessPrivate + * + **********************************************************************/ +Q3ProcessManager *Q3ProcessPrivate::procManager = 0; + +Q3ProcessPrivate::Q3ProcessPrivate() +{ +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessPrivate: Constructor" ); +#endif + stdinBufRead = 0; + + notifierStdin = 0; + notifierStdout = 0; + notifierStderr = 0; + + exitValuesCalculated = false; + socketReadCalled = false; + + proc = 0; +} + +Q3ProcessPrivate::~Q3ProcessPrivate() +{ +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3ProcessPrivate: Destructor" ); +#endif + + if ( proc != 0 ) { + if ( proc->socketStdin != 0 ) { + ::close( proc->socketStdin ); + proc->socketStdin = 0; + } + proc->process = 0; + } + + while ( !stdinBuf.isEmpty() ) { + delete stdinBuf.dequeue(); + } + delete notifierStdin; + delete notifierStdout; + delete notifierStderr; +} + +/* + Closes all open sockets in the child process that are not needed by the child + process. Otherwise one child may have an open socket on standard input, etc. + of another child. +*/ +void Q3ProcessPrivate::closeOpenSocketsForChild() +{ + if ( procManager != 0 ) { + if ( procManager->sigchldFd[0] != 0 ) + ::close( procManager->sigchldFd[0] ); + if ( procManager->sigchldFd[1] != 0 ) + ::close( procManager->sigchldFd[1] ); + + // close also the sockets from other Q3Process instances + for ( QProc *p=procManager->procList->first(); p!=0; p=procManager->procList->next() ) { + ::close( p->socketStdin ); + ::close( p->socketStdout ); + ::close( p->socketStderr ); + } + } +} + +void Q3ProcessPrivate::newProc( pid_t pid, Q3Process *process ) +{ + proc = new QProc( pid, process ); + if ( procManager == 0 ) { + procManager = new Q3ProcessManager; + qAddPostRoutine(q3process_cleanup); + } + // the Q3ProcessManager takes care of deleting the QProc instances + procManager->append( proc ); +} + +/*********************************************************************** + * + * sigchld handler callback + * + **********************************************************************/ +static QT_SIGNAL_RETTYPE qt_C_sigchldHnd(QT_SIGNAL_ARGS) +{ + if ( Q3ProcessPrivate::procManager == 0 ) + return; + if ( Q3ProcessPrivate::procManager->sigchldFd[0] == 0 ) + return; + + char a = 1; + ::write( Q3ProcessPrivate::procManager->sigchldFd[0], &a, sizeof(a) ); +} + + +/*********************************************************************** + * + * Q3Process + * + **********************************************************************/ +/* + This private class does basic initialization. +*/ +void Q3Process::init() +{ + d = new Q3ProcessPrivate(); + exitStat = 0; + exitNormal = false; +} + +/* + This private class resets the process variables, etc. so that it can be used + for another process to start. +*/ +void Q3Process::reset() +{ + delete d; + d = new Q3ProcessPrivate(); + exitStat = 0; + exitNormal = false; + d->bufStdout.clear(); + d->bufStderr.clear(); +} + +Q3Membuf* Q3Process::membufStdout() +{ + if ( d->proc && d->proc->socketStdout ) { + /* + Apparently, there is not consistency among different + operating systems on how to use FIONREAD. + + FreeBSD, Linux and Solaris all expect the 3rd argument to + ioctl() to be an int, which is normally 32-bit even on + 64-bit machines. + + IRIX, on the other hand, expects a size_t, which is 64-bit + on 64-bit machines. + + So, the solution is to use size_t initialized to zero to + make sure all bits are set to zero, preventing underflow + with the FreeBSD/Linux/Solaris ioctls. + */ + size_t nbytes = 0; + if ( ::ioctl(d->proc->socketStdout, FIONREAD, (char*)&nbytes)==0 && nbytes>0 ) + socketRead( d->proc->socketStdout ); + } + return &d->bufStdout; +} + +Q3Membuf* Q3Process::membufStderr() +{ + if ( d->proc && d->proc->socketStderr ) { + /* + Apparently, there is not consistency among different + operating systems on how to use FIONREAD. + + FreeBSD, Linux and Solaris all expect the 3rd argument to + ioctl() to be an int, which is normally 32-bit even on + 64-bit machines. + + IRIX, on the other hand, expects a size_t, which is 64-bit + on 64-bit machines. + + So, the solution is to use size_t initialized to zero to + make sure all bits are set to zero, preventing underflow + with the FreeBSD/Linux/Solaris ioctls. + */ + size_t nbytes = 0; + if ( ::ioctl(d->proc->socketStderr, FIONREAD, (char*)&nbytes)==0 && nbytes>0 ) + socketRead( d->proc->socketStderr ); + } + return &d->bufStderr; +} + +Q3Process::~Q3Process() +{ + delete d; +} + +bool Q3Process::start( QStringList *env ) +{ +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::start()" ); +#endif + reset(); + + int sStdin[2]; + int sStdout[2]; + int sStderr[2]; + + // open sockets for piping +#ifndef Q_OS_QNX6 + if ( (comms & Stdin) && ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStdin ) == -1 ) { +#else + if ( (comms & Stdin) && qnx6SocketPairReplacement(sStdin) == -1 ) { +#endif + return false; + } +#ifndef Q_OS_QNX6 + if ( (comms & Stderr) && ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStderr ) == -1 ) { +#else + if ( (comms & Stderr) && qnx6SocketPairReplacement(sStderr) == -1 ) { +#endif + if ( comms & Stdin ) { + ::close( sStdin[0] ); + ::close( sStdin[1] ); + } + return false; + } +#ifndef Q_OS_QNX6 + if ( (comms & Stdout) && ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStdout ) == -1 ) { +#else + if ( (comms & Stdout) && qnx6SocketPairReplacement(sStdout) == -1 ) { +#endif + if ( comms & Stdin ) { + ::close( sStdin[0] ); + ::close( sStdin[1] ); + } + if ( comms & Stderr ) { + ::close( sStderr[0] ); + ::close( sStderr[1] ); + } + return false; + } + + // the following pipe is only used to determine if the process could be + // started + int fd[2]; + if ( pipe( fd ) < 0 ) { + // non critical error, go on + fd[0] = 0; + fd[1] = 0; + } + + // construct the arguments for exec + Q3CString *arglistQ = new Q3CString[ _arguments.count() + 1 ]; + const char** arglist = new const char*[ _arguments.count() + 1 ]; + int i = 0; + for ( QStringList::Iterator it = _arguments.begin(); it != _arguments.end(); ++it ) { + arglistQ[i] = (*it).local8Bit(); + arglist[i] = arglistQ[i]; +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::start(): arg %d = %s", i, arglist[i] ); +#endif + i++; + } +#ifdef Q_OS_MACX + if(i) { + Q3CString arg_bundle = arglistQ[0]; + QFileInfo fi(QString::fromUtf8(arg_bundle.constData())); + if(fi.exists() && fi.isDir() && arg_bundle.right(4) == ".app") { + Q3CString exe = arg_bundle; + int lslash = exe.findRev('/'); + if(lslash != -1) + exe = exe.mid(lslash+1); + exe = Q3CString(arg_bundle + "/Contents/MacOS/" + exe); + exe = exe.left(exe.length() - 4); //chop off the .app + if(QFile::exists(QString::fromLatin1(exe.constData()))) { + arglistQ[0] = exe; + arglist[0] = arglistQ[0]; + } + } + } +#endif + arglist[i] = 0; + + // Must make sure signal handlers are installed before exec'ing + // in case the process exits quickly. + if ( d->procManager == 0 ) { + d->procManager = new Q3ProcessManager; + qAddPostRoutine(q3process_cleanup); + } + + // fork and exec + QApplication::flushX(); + pid_t pid = fork(); + if ( pid == 0 ) { + // child + d->closeOpenSocketsForChild(); + if ( comms & Stdin ) { + ::close( sStdin[1] ); + ::dup2( sStdin[0], STDIN_FILENO ); + } + if ( comms & Stdout ) { + ::close( sStdout[0] ); + ::dup2( sStdout[1], STDOUT_FILENO ); + } + if ( comms & Stderr ) { + ::close( sStderr[0] ); + ::dup2( sStderr[1], STDERR_FILENO ); + } + if ( comms & DupStderr ) { + ::dup2( STDOUT_FILENO, STDERR_FILENO ); + } +#ifndef QT_NO_DIR + ::chdir( workingDir.absPath().latin1() ); +#endif + if ( fd[0] ) + ::close( fd[0] ); + if ( fd[1] ) + ::fcntl( fd[1], F_SETFD, FD_CLOEXEC ); // close on exec shows success + + if ( env == 0 ) { // inherit environment and start process +#ifndef Q_OS_QNX4 + ::execvp( arglist[0], (char*const*)arglist ); // ### cast not nice +#else + ::execvp( arglist[0], (char const*const*)arglist ); // ### cast not nice +#endif + } else { // start process with environment settins as specified in env + // construct the environment for exec + int numEntries = env->count(); +#if defined(Q_OS_MACX) + QString ld_library_path(QLatin1String("DYLD_LIBRARY_PATH")); +#else + QString ld_library_path(QLatin1String("LD_LIBRARY_PATH")); +#endif + bool setLibraryPath = + env->grep( QRegExp( QLatin1Char('^') + ld_library_path + QLatin1Char('=') ) ).empty() && + getenv( ld_library_path.local8Bit() ) != 0; + if ( setLibraryPath ) + numEntries++; + Q3CString *envlistQ = new Q3CString[ numEntries + 1 ]; + const char** envlist = new const char*[ numEntries + 1 ]; + int i = 0; + if ( setLibraryPath ) { + envlistQ[i] = QString( ld_library_path + QLatin1String("=%1") ).arg( QString::fromLocal8Bit(getenv( ld_library_path.local8Bit() )) ).local8Bit(); + envlist[i] = envlistQ[i]; + i++; + } + for ( QStringList::Iterator it = env->begin(); it != env->end(); ++it ) { + envlistQ[i] = (*it).local8Bit(); + envlist[i] = envlistQ[i]; + i++; + } + envlist[i] = 0; + + // look for the executable in the search path + if ( _arguments.count()>0 && getenv("PATH")!=0 ) { + QString command = _arguments[0]; + if ( !command.contains( QLatin1Char('/') ) ) { + QStringList pathList = QStringList::split( QLatin1Char(':'), QString::fromLocal8Bit(getenv( "PATH" )) ); + for (QStringList::Iterator it = pathList.begin(); it != pathList.end(); ++it ) { + QString dir = *it; +#if defined(Q_OS_MACX) //look in a bundle + if(!QFile::exists(dir + QLatin1Char('/') + command) && QFile::exists(dir + QLatin1Char('/') + command + QLatin1String(".app"))) + dir += QLatin1Char('/') + command + QLatin1String(".app/Contents/MacOS"); +#endif +#ifndef QT_NO_DIR + QFileInfo fileInfo( dir, command ); +#else + QFileInfo fileInfo( dir + "/" + command ); +#endif + if ( fileInfo.isExecutable() ) { +#if defined(Q_OS_MACX) + arglistQ[0] = fileInfo.absFilePath().local8Bit(); +#else + arglistQ[0] = fileInfo.filePath().local8Bit(); +#endif + arglist[0] = arglistQ[0]; + break; + } + } + } + } +#ifndef Q_OS_QNX4 + ::execve( arglist[0], (char*const*)arglist, (char*const*)envlist ); // ### casts not nice +#else + ::execve( arglist[0], (char const*const*)arglist,(char const*const*)envlist ); // ### casts not nice +#endif + } + if ( fd[1] ) { + char buf = 0; + ::write( fd[1], &buf, 1 ); + ::close( fd[1] ); + } + ::_exit( -1 ); + } else if ( pid == -1 ) { + // error forking + goto error; + } + + // test if exec was successful + if ( fd[1] ) + ::close( fd[1] ); + if ( fd[0] ) { + char buf; + for ( ;; ) { + int n = ::read( fd[0], &buf, 1 ); + if ( n==1 ) { + // socket was not closed => error + if ( ::waitpid( pid, 0, WNOHANG ) != pid ) { + // The wait did not succeed yet, so try again when we get + // the sigchild (to avoid zombies). + d->newProc( pid, 0 ); + } + d->proc = 0; + goto error; + } else if ( n==-1 ) { + if ( errno==EAGAIN || errno==EINTR ) + // try it again + continue; + } + break; + } + ::close( fd[0] ); + } + + d->newProc( pid, this ); + + if ( comms & Stdin ) { + ::close( sStdin[0] ); + d->proc->socketStdin = sStdin[1]; + + // Select non-blocking mode + int originalFlags = fcntl(d->proc->socketStdin, F_GETFL, 0); + fcntl(d->proc->socketStdin, F_SETFL, originalFlags | O_NONBLOCK); + + d->notifierStdin = new QSocketNotifier( sStdin[1], QSocketNotifier::Write ); + connect( d->notifierStdin, SIGNAL(activated(int)), + this, SLOT(socketWrite(int)) ); + // setup notifiers for the sockets + if ( !d->stdinBuf.isEmpty() ) { + d->notifierStdin->setEnabled( true ); + } + } + if ( comms & Stdout ) { + ::close( sStdout[1] ); + d->proc->socketStdout = sStdout[0]; + d->notifierStdout = new QSocketNotifier( sStdout[0], QSocketNotifier::Read ); + connect( d->notifierStdout, SIGNAL(activated(int)), + this, SLOT(socketRead(int)) ); + if ( ioRedirection ) + d->notifierStdout->setEnabled( true ); + } + if ( comms & Stderr ) { + ::close( sStderr[1] ); + d->proc->socketStderr = sStderr[0]; + d->notifierStderr = new QSocketNotifier( sStderr[0], QSocketNotifier::Read ); + connect( d->notifierStderr, SIGNAL(activated(int)), + this, SLOT(socketRead(int)) ); + if ( ioRedirection ) + d->notifierStderr->setEnabled( true ); + } + + // cleanup and return + delete[] arglistQ; + delete[] arglist; + return true; + +error: +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::start(): error starting process" ); +#endif + if ( d->procManager ) + d->procManager->cleanup(); + if ( comms & Stdin ) { + ::close( sStdin[1] ); + ::close( sStdin[0] ); + } + if ( comms & Stdout ) { + ::close( sStdout[0] ); + ::close( sStdout[1] ); + } + if ( comms & Stderr ) { + ::close( sStderr[0] ); + ::close( sStderr[1] ); + } + ::close( fd[0] ); + ::close( fd[1] ); + delete[] arglistQ; + delete[] arglist; + return false; +} + + +void Q3Process::tryTerminate() const +{ + if ( d->proc != 0 ) + ::kill( d->proc->pid, SIGTERM ); +} + +void Q3Process::kill() const +{ + if ( d->proc != 0 ) + ::kill( d->proc->pid, SIGKILL ); +} + +bool Q3Process::isRunning() const +{ + if ( d->exitValuesCalculated ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::isRunning(): false (already computed)" ); +#endif + return false; + } + if ( d->proc == 0 ) + return false; + int status; + if ( ::waitpid( d->proc->pid, &status, WNOHANG ) == d->proc->pid ) { + // compute the exit values + Q3Process *that = (Q3Process*)this; // mutable + that->exitNormal = WIFEXITED( status ) != 0; + if ( exitNormal ) { + that->exitStat = (char)WEXITSTATUS( status ); + } + d->exitValuesCalculated = true; + + // On heavy processing, the socket notifier for the sigchild might not + // have found time to fire yet. + if ( d->procManager && d->procManager->sigchldFd[1] < FD_SETSIZE ) { + fd_set fds; + struct timeval tv; + FD_ZERO( &fds ); + FD_SET( d->procManager->sigchldFd[1], &fds ); + tv.tv_sec = 0; + tv.tv_usec = 0; + if ( ::select( d->procManager->sigchldFd[1]+1, &fds, 0, 0, &tv ) > 0 ) + d->procManager->sigchldHnd( d->procManager->sigchldFd[1] ); + } + +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::isRunning() (PID: %d): false", d->proc->pid ); +#endif + return false; + } +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::isRunning() (PID: %d): true", d->proc->pid ); +#endif + return true; +} + +bool Q3Process::canReadLineStdout() const +{ + if ( !d->proc || !d->proc->socketStdout ) + return d->bufStdout.size() != 0; + + Q3Process *that = (Q3Process*)this; + return that->membufStdout()->scanNewline( 0 ); +} + +bool Q3Process::canReadLineStderr() const +{ + if ( !d->proc || !d->proc->socketStderr ) + return d->bufStderr.size() != 0; + + Q3Process *that = (Q3Process*)this; + return that->membufStderr()->scanNewline( 0 ); +} + +void Q3Process::writeToStdin( const QByteArray& buf ) +{ +#if defined(QT_Q3PROCESS_DEBUG) +// qDebug( "Q3Process::writeToStdin(): write to stdin (%d)", d->socketStdin ); +#endif + d->stdinBuf.enqueue( new QByteArray(buf) ); + if ( d->notifierStdin != 0 ) + d->notifierStdin->setEnabled( true ); +} + + +void Q3Process::closeStdin() +{ + if ( d->proc == 0 ) + return; + if ( d->proc->socketStdin !=0 ) { + while ( !d->stdinBuf.isEmpty() ) { + delete d->stdinBuf.dequeue(); + } + d->notifierStdin->setEnabled(false); + qDeleteInEventHandler(d->notifierStdin); + d->notifierStdin = 0; + if ( ::close( d->proc->socketStdin ) != 0 ) { + qWarning( "Could not close stdin of child process" ); + } +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::closeStdin(): stdin (%d) closed", d->proc->socketStdin ); +#endif + d->proc->socketStdin = 0; + } +} + + +/* + This private slot is called when the process has outputted data to either + standard output or standard error. +*/ +void Q3Process::socketRead( int fd ) +{ + if ( d->socketReadCalled ) { + // the slots that are connected to the readyRead...() signals might + // trigger a recursive call of socketRead(). Avoid this since you get a + // blocking read otherwise. + return; + } + +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::socketRead(): %d", fd ); +#endif + if ( fd == 0 ) + return; + if ( !d->proc ) + return; + Q3Membuf *buffer = 0; + int n; + if ( fd == d->proc->socketStdout ) { + buffer = &d->bufStdout; + } else if ( fd == d->proc->socketStderr ) { + buffer = &d->bufStderr; + } else { + // this case should never happen, but just to be safe + return; + } +#if defined(QT_Q3PROCESS_DEBUG) + uint oldSize = buffer->size(); +#endif + + // try to read data first (if it fails, the filedescriptor was closed) + const int basize = 4096; + QByteArray *ba = new QByteArray( basize ); + n = ::read( fd, ba->data(), basize ); + if ( n > 0 ) { + ba->resize( n ); + buffer->append( ba ); + ba = 0; + } else { + delete ba; + ba = 0; + } + // eof or error? + if ( n == 0 || n == -1 ) { + if ( fd == d->proc->socketStdout ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::socketRead(): stdout (%d) closed", fd ); +#endif + d->notifierStdout->setEnabled( false ); + qDeleteInEventHandler(d->notifierStdout); + d->notifierStdout = 0; + ::close( d->proc->socketStdout ); + d->proc->socketStdout = 0; + return; + } else if ( fd == d->proc->socketStderr ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::socketRead(): stderr (%d) closed", fd ); +#endif + d->notifierStderr->setEnabled( false ); + qDeleteInEventHandler(d->notifierStderr); + d->notifierStderr = 0; + ::close( d->proc->socketStderr ); + d->proc->socketStderr = 0; + return; + } + } + + if ( fd < FD_SETSIZE ) { + fd_set fds; + struct timeval tv; + FD_ZERO( &fds ); + FD_SET( fd, &fds ); + tv.tv_sec = 0; + tv.tv_usec = 0; + while ( ::select( fd+1, &fds, 0, 0, &tv ) > 0 ) { + // prepare for the next round + FD_ZERO( &fds ); + FD_SET( fd, &fds ); + // read data + ba = new QByteArray( basize ); + n = ::read( fd, ba->data(), basize ); + if ( n > 0 ) { + ba->resize( n ); + buffer->append( ba ); + ba = 0; + } else { + delete ba; + ba = 0; + break; + } + } + } + + d->socketReadCalled = true; + if ( fd == d->proc->socketStdout ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::socketRead(): %d bytes read from stdout (%d)", + buffer->size()-oldSize, fd ); +#endif + emit readyReadStdout(); + } else if ( fd == d->proc->socketStderr ) { +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::socketRead(): %d bytes read from stderr (%d)", + buffer->size()-oldSize, fd ); +#endif + emit readyReadStderr(); + } + d->socketReadCalled = false; +} + + +/* + This private slot is called when the process tries to read data from standard + input. +*/ +void Q3Process::socketWrite( int fd ) +{ + while ( fd == d->proc->socketStdin && d->proc->socketStdin != 0 ) { + if ( d->stdinBuf.isEmpty() ) { + d->notifierStdin->setEnabled( false ); + return; + } + ssize_t ret = ::write( fd, + d->stdinBuf.head()->data() + d->stdinBufRead, + d->stdinBuf.head()->size() - d->stdinBufRead ); +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::socketWrite(): wrote %d bytes to stdin (%d)", ret, fd ); +#endif + if ( ret == -1 ) + return; + d->stdinBufRead += ret; + if ( d->stdinBufRead == (ssize_t)d->stdinBuf.head()->size() ) { + d->stdinBufRead = 0; + delete d->stdinBuf.dequeue(); + if ( wroteToStdinConnected && d->stdinBuf.isEmpty() ) + emit wroteToStdin(); + } + } +} + +/*! + \internal + Flushes standard input. This is useful if you want to use Q3Process in a + synchronous manner. + + This function should probably go into the public API. +*/ +void Q3Process::flushStdin() +{ + if (d->proc) + socketWrite(d->proc->socketStdin); +} + +/* + This private slot is only used under Windows (but moc does not know about #if + defined()). +*/ +void Q3Process::timeout() +{ +} + + +/* + This private function is used by connectNotify() and disconnectNotify() to + change the value of ioRedirection (and related behaviour) +*/ +void Q3Process::setIoRedirection( bool value ) +{ + ioRedirection = value; + if ( ioRedirection ) { + if ( d->notifierStdout ) + d->notifierStdout->setEnabled( true ); + if ( d->notifierStderr ) + d->notifierStderr->setEnabled( true ); + } else { + if ( d->notifierStdout ) + d->notifierStdout->setEnabled( false ); + if ( d->notifierStderr ) + d->notifierStderr->setEnabled( false ); + } +} + +/* + This private function is used by connectNotify() and + disconnectNotify() to change the value of notifyOnExit (and related + behaviour) +*/ +void Q3Process::setNotifyOnExit( bool value ) +{ + notifyOnExit = value; +} + +/* + This private function is used by connectNotify() and disconnectNotify() to + change the value of wroteToStdinConnected (and related behaviour) +*/ +void Q3Process::setWroteStdinConnected( bool value ) +{ + wroteToStdinConnected = value; +} + +/*! + \typedef Q3Process::PID + \internal +*/ + +Q3Process::PID Q3Process::processIdentifier() +{ + if ( d->proc == 0 ) + return -1; + return d->proc->pid; +} + +QT_END_NAMESPACE + +#endif // QT_NO_PROCESS diff --git a/src/qt3support/other/q3process_win.cpp b/src/qt3support/other/q3process_win.cpp new file mode 100644 index 0000000..3c862ee --- /dev/null +++ b/src/qt3support/other/q3process_win.cpp @@ -0,0 +1,676 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qplatformdefs.h" +#include "q3process.h" + +#ifndef QT_NO_PROCESS + +#include "qapplication.h" +#include "q3cstring.h" +#include "q3ptrqueue.h" +#include "qtimer.h" +#include "qregexp.h" +#include "private/q3membuf_p.h" +#include "qt_windows.h" + +#ifdef Q_OS_WINCE +#define STARTF_USESTDHANDLES 1 +#endif + +QT_BEGIN_NAMESPACE + +//#define QT_Q3PROCESS_DEBUG + +/*********************************************************************** + * + * Q3ProcessPrivate + * + **********************************************************************/ +class Q3ProcessPrivate +{ +public: + Q3ProcessPrivate( Q3Process *proc ) + { + stdinBufRead = 0; + pipeStdin[0] = 0; + pipeStdin[1] = 0; + pipeStdout[0] = 0; + pipeStdout[1] = 0; + pipeStderr[0] = 0; + pipeStderr[1] = 0; + exitValuesCalculated = false; + + lookup = new QTimer( proc ); + qApp->connect( lookup, SIGNAL(timeout()), + proc, SLOT(timeout()) ); + + pid = 0; + } + + ~Q3ProcessPrivate() + { + reset(); + } + + void reset() + { + while ( !stdinBuf.isEmpty() ) { + delete stdinBuf.dequeue(); + } + closeHandles(); + stdinBufRead = 0; + pipeStdin[0] = 0; + pipeStdin[1] = 0; + pipeStdout[0] = 0; + pipeStdout[1] = 0; + pipeStderr[0] = 0; + pipeStderr[1] = 0; + exitValuesCalculated = false; + + deletePid(); + } + + void closeHandles() + { + if( pipeStdin[1] != 0 ) { + CloseHandle( pipeStdin[1] ); + pipeStdin[1] = 0; + } + if( pipeStdout[0] != 0 ) { + CloseHandle( pipeStdout[0] ); + pipeStdout[0] = 0; + } + if( pipeStderr[0] != 0 ) { + CloseHandle( pipeStderr[0] ); + pipeStderr[0] = 0; + } + } + + void deletePid() + { + if ( pid ) { + CloseHandle( pid->hProcess ); + CloseHandle( pid->hThread ); + delete pid; + pid = 0; + } + } + + void newPid() + { + deletePid(); + pid = new PROCESS_INFORMATION; + memset( pid, 0, sizeof(PROCESS_INFORMATION) ); + } + + Q3Membuf bufStdout; + Q3Membuf bufStderr; + + Q3PtrQueue<QByteArray> stdinBuf; + + HANDLE pipeStdin[2]; + HANDLE pipeStdout[2]; + HANDLE pipeStderr[2]; + QTimer *lookup; + + PROCESS_INFORMATION *pid; + uint stdinBufRead; + + bool exitValuesCalculated; +}; + + +/*********************************************************************** + * + * Q3Process + * + **********************************************************************/ +void Q3Process::init() +{ + d = new Q3ProcessPrivate( this ); + exitStat = 0; + exitNormal = false; +} + +void Q3Process::reset() +{ + d->reset(); + exitStat = 0; + exitNormal = false; + d->bufStdout.clear(); + d->bufStderr.clear(); +} + +Q3Membuf* Q3Process::membufStdout() +{ + if( d->pipeStdout[0] != 0 ) + socketRead( 1 ); + return &d->bufStdout; +} + +Q3Membuf* Q3Process::membufStderr() +{ + if( d->pipeStderr[0] != 0 ) + socketRead( 2 ); + return &d->bufStderr; +} + +Q3Process::~Q3Process() +{ + delete d; +} + +bool Q3Process::start( QStringList *env ) +{ +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::start()" ); +#endif + reset(); + + if ( _arguments.isEmpty() ) + return false; + + // Open the pipes. Make non-inheritable copies of input write and output + // read handles to avoid non-closable handles (this is done by the + // DuplicateHandle() call). + SECURITY_ATTRIBUTES secAtt = { sizeof( SECURITY_ATTRIBUTES ), NULL, TRUE }; +#ifndef Q_OS_WINCE + // I guess there is no stdin stdout and stderr on Q_OS_WINCE to dup + // CreatePipe and DupilcateHandle aren't available for Q_OS_WINCE + HANDLE tmpStdin, tmpStdout, tmpStderr; + if ( comms & Stdin ) { + if ( !CreatePipe( &d->pipeStdin[0], &tmpStdin, &secAtt, 0 ) ) { + d->closeHandles(); + return false; + } + if ( !DuplicateHandle( GetCurrentProcess(), tmpStdin, GetCurrentProcess(), &d->pipeStdin[1], 0, FALSE, DUPLICATE_SAME_ACCESS ) ) { + d->closeHandles(); + return false; + } + if ( !CloseHandle( tmpStdin ) ) { + d->closeHandles(); + return false; + } + } + if ( comms & Stdout ) { + if ( !CreatePipe( &tmpStdout, &d->pipeStdout[1], &secAtt, 0 ) ) { + d->closeHandles(); + return false; + } + if ( !DuplicateHandle( GetCurrentProcess(), tmpStdout, GetCurrentProcess(), &d->pipeStdout[0], 0, FALSE, DUPLICATE_SAME_ACCESS ) ) { + d->closeHandles(); + return false; + } + if ( !CloseHandle( tmpStdout ) ) { + d->closeHandles(); + return false; + } + } + if ( comms & Stderr ) { + if ( !CreatePipe( &tmpStderr, &d->pipeStderr[1], &secAtt, 0 ) ) { + d->closeHandles(); + return false; + } + if ( !DuplicateHandle( GetCurrentProcess(), tmpStderr, GetCurrentProcess(), &d->pipeStderr[0], 0, FALSE, DUPLICATE_SAME_ACCESS ) ) { + d->closeHandles(); + return false; + } + if ( !CloseHandle( tmpStderr ) ) { + d->closeHandles(); + return false; + } + } + if ( comms & DupStderr ) { + CloseHandle( d->pipeStderr[1] ); + d->pipeStderr[1] = d->pipeStdout[1]; + } +#endif + + // construct the arguments for CreateProcess() + QString args; + QString appName; + QStringList::Iterator it = _arguments.begin(); + args = *it; + ++it; + if ( args.endsWith( QLatin1String(".bat") ) && args.contains( QLatin1Char(' ') ) ) { + // CreateProcess() seems to have a strange semantics (see also + // http://www.experts-exchange.com/Programming/Programming_Platforms/Win_Prog/Q_11138647.html): + // If you start a batch file with spaces in the filename, the first + // argument to CreateProcess() must be the name of the batchfile + // without quotes, but the second argument must start with the same + // argument with quotes included. But if the same approach is used for + // .exe files, it doesn't work. + appName = args; + args = QLatin1Char('"') + args + QLatin1Char('"'); + } + for ( ; it != _arguments.end(); ++it ) { + QString tmp = *it; + // escape a single " because the arguments will be parsed + tmp.replace( QLatin1String("\""), QLatin1String("\\\"") ); + if ( tmp.isEmpty() || tmp.contains( QLatin1Char(' ') ) || tmp.contains( QLatin1Char('\t') ) ) { + // The argument must not end with a \ since this would be interpreted + // as escaping the quote -- rather put the \ behind the quote: e.g. + // rather use "foo"\ than "foo\" + QString endQuote( QLatin1String("\"") ); + int i = tmp.length(); + while ( i>0 && tmp.at( i-1 ) == QLatin1Char('\\') ) { + --i; + endQuote += QLatin1String("\\"); + } + args += QString( QLatin1String(" \"") ) + tmp.left( i ) + endQuote; + } else { + args += QLatin1Char(' ') + tmp; + } + } +#if defined(QT_Q3PROCESS_DEBUG) + qDebug( "Q3Process::start(): args [%s]", args.latin1() ); +#endif + + // CreateProcess() + bool success; + d->newPid(); +#ifdef UNICODE + if (!(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based)) { + STARTUPINFOW startupInfo = { + sizeof( STARTUPINFO ), 0, 0, 0, + (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, + 0, 0, 0, + STARTF_USESTDHANDLES, + 0, 0, 0, + d->pipeStdin[0], d->pipeStdout[1], d->pipeStderr[1] + }; + TCHAR *applicationName; + if ( appName.isNull() ) + applicationName = 0; + else + applicationName = _wcsdup( (TCHAR*)appName.ucs2() ); + TCHAR *commandLine = _wcsdup( (TCHAR*)args.ucs2() ); + QByteArray envlist; + if ( env != 0 ) { + int pos = 0; + // add PATH if necessary (for DLL loading) + QByteArray path = qgetenv( "PATH" ); + if ( env->grep( QRegExp(QLatin1String("^PATH="),FALSE) ).empty() && !path.isNull() ) { + QString tmp = QString( QLatin1String("PATH=%1") ).arg(QString::fromLatin1(path.constData())); + uint tmpSize = sizeof(TCHAR) * (tmp.length()+1); + envlist.resize( envlist.size() + tmpSize ); + memcpy( envlist.data()+pos, tmp.ucs2(), tmpSize ); + pos += tmpSize; + } + // add the user environment + for ( QStringList::Iterator it = env->begin(); it != env->end(); it++ ) { + QString tmp = *it; + uint tmpSize = sizeof(TCHAR) * (tmp.length()+1); + envlist.resize( envlist.size() + tmpSize ); + memcpy( envlist.data()+pos, tmp.ucs2(), tmpSize ); + pos += tmpSize; + } + // add the 2 terminating 0 (actually 4, just to be on the safe side) + envlist.resize( envlist.size()+4 ); + envlist[pos++] = 0; + envlist[pos++] = 0; + envlist[pos++] = 0; + envlist[pos++] = 0; + } + success = CreateProcessW( applicationName, commandLine, + 0, 0, TRUE, ( comms==0 ? CREATE_NEW_CONSOLE : CREATE_NO_WINDOW ) +#ifndef Q_OS_WINCE + | CREATE_UNICODE_ENVIRONMENT +#endif + , env==0 ? 0 : envlist.data(), + (TCHAR*)QDir::toNativeSeparators(workingDir.absPath()).ucs2(), + &startupInfo, d->pid ); + free( applicationName ); + free( commandLine ); + } else +#endif // UNICODE + { +#ifndef Q_OS_WINCE + STARTUPINFOA startupInfo = { sizeof( STARTUPINFOA ), 0, 0, 0, + (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, (ulong)CW_USEDEFAULT, + 0, 0, 0, + STARTF_USESTDHANDLES, + 0, 0, 0, + d->pipeStdin[0], d->pipeStdout[1], d->pipeStderr[1] + }; + QByteArray envlist; + if ( env != 0 ) { + int pos = 0; + // add PATH if necessary (for DLL loading) + QByteArray path = qgetenv( "PATH" ); + if ( env->grep( QRegExp(QLatin1String("^PATH="),FALSE) ).empty() && !path.isNull() ) { + Q3CString tmp = QString( QLatin1String("PATH=%1") ).arg(QString::fromLatin1(path.constData())).local8Bit(); + uint tmpSize = tmp.length() + 1; + envlist.resize( envlist.size() + tmpSize ); + memcpy( envlist.data()+pos, tmp.data(), tmpSize ); + pos += tmpSize; + } + // add the user environment + for ( QStringList::Iterator it = env->begin(); it != env->end(); it++ ) { + Q3CString tmp = (*it).local8Bit(); + uint tmpSize = tmp.length() + 1; + envlist.resize( envlist.size() + tmpSize ); + memcpy( envlist.data()+pos, tmp.data(), tmpSize ); + pos += tmpSize; + } + // add the terminating 0 (actually 2, just to be on the safe side) + envlist.resize( envlist.size()+2 ); + envlist[pos++] = 0; + envlist[pos++] = 0; + } + char *applicationName; + if ( appName.isNull() ) + applicationName = 0; + else + applicationName = const_cast<char *>(appName.toLocal8Bit().data()); + success = CreateProcessA( applicationName, + const_cast<char *>(args.toLocal8Bit().data()), + 0, 0, TRUE, comms==0 ? CREATE_NEW_CONSOLE : DETACHED_PROCESS, + env==0 ? 0 : envlist.data(), + (const char*)QDir::toNativeSeparators(workingDir.absPath()).local8Bit(), + &startupInfo, d->pid ); +#endif // Q_OS_WINCE + } + if ( !success ) { + d->deletePid(); + return false; + } + +#ifndef Q_OS_WINCE + if ( comms & Stdin ) + CloseHandle( d->pipeStdin[0] ); + if ( comms & Stdout ) + CloseHandle( d->pipeStdout[1] ); + if ( (comms & Stderr) && !(comms & DupStderr) ) + CloseHandle( d->pipeStderr[1] ); +#endif + + if ( ioRedirection || notifyOnExit ) { + d->lookup->start( 100 ); + } + + // cleanup and return + return true; +} + +static BOOL CALLBACK qt_terminateApp( HWND hwnd, LPARAM procId ) +{ + DWORD procId_win; + GetWindowThreadProcessId( hwnd, &procId_win ); + if( procId_win == (DWORD)procId ) + PostMessage( hwnd, WM_CLOSE, 0, 0 ); + + return TRUE; +} + +void Q3Process::tryTerminate() const +{ + if ( d->pid ) + EnumWindows( qt_terminateApp, (LPARAM)d->pid->dwProcessId ); +} + +void Q3Process::kill() const +{ + if ( d->pid ) + TerminateProcess( d->pid->hProcess, 0xf291 ); +} + +bool Q3Process::isRunning() const +{ + if ( !d->pid ) + return false; + + if ( WaitForSingleObject( d->pid->hProcess, 0) == WAIT_OBJECT_0 ) { + // there might be data to read + Q3Process *that = (Q3Process*)this; + that->socketRead( 1 ); // try stdout + that->socketRead( 2 ); // try stderr + // compute the exit values + if ( !d->exitValuesCalculated ) { + DWORD exitCode; + if ( GetExitCodeProcess( d->pid->hProcess, &exitCode ) ) { + if ( exitCode != STILL_ACTIVE ) { // this should ever be true? + that->exitNormal = exitCode != 0xf291; + that->exitStat = exitCode; + } + } + d->exitValuesCalculated = true; + } + d->deletePid(); + d->closeHandles(); + return false; + } else { + return true; + } +} + +bool Q3Process::canReadLineStdout() const +{ + if( !d->pipeStdout[0] ) + return d->bufStdout.size() != 0; + + Q3Process *that = (Q3Process*)this; + return that->membufStdout()->scanNewline( 0 ); +} + +bool Q3Process::canReadLineStderr() const +{ + if( !d->pipeStderr[0] ) + return d->bufStderr.size() != 0; + + Q3Process *that = (Q3Process*)this; + return that->membufStderr()->scanNewline( 0 ); +} + +void Q3Process::writeToStdin( const QByteArray& buf ) +{ + d->stdinBuf.enqueue( new QByteArray(buf) ); + socketWrite( 0 ); +} + +void Q3Process::closeStdin( ) +{ + if ( d->pipeStdin[1] != 0 ) { + CloseHandle( d->pipeStdin[1] ); + d->pipeStdin[1] = 0; + } +} + +void Q3Process::socketRead( int fd ) +{ + // fd == 1: stdout, fd == 2: stderr + HANDLE dev; + if ( fd == 1 ) { + dev = d->pipeStdout[0]; + } else if ( fd == 2 ) { + dev = d->pipeStderr[0]; + } else { + return; + } +#ifndef Q_OS_WINCE + // get the number of bytes that are waiting to be read + unsigned long i, r; + char dummy; + if ( !PeekNamedPipe( dev, &dummy, 1, &r, &i, 0 ) ) { + return; // ### is it worth to dig for the reason of the error? + } +#else + unsigned long i = 1000; +#endif + if ( i > 0 ) { + Q3Membuf *buffer; + if ( fd == 1 ) + buffer = &d->bufStdout; + else + buffer = &d->bufStderr; + + QByteArray *ba = new QByteArray( i ); + uint sz = readStddev( dev, ba->data(), i ); + if ( sz != i ) + ba->resize( i ); + + if ( sz == 0 ) { + delete ba; + return; + } + buffer->append( ba ); + if ( fd == 1 ) + emit readyReadStdout(); + else + emit readyReadStderr(); + } +} + +void Q3Process::socketWrite( int ) +{ + DWORD written; + while ( !d->stdinBuf.isEmpty() && isRunning() ) { + if ( !WriteFile( d->pipeStdin[1], + d->stdinBuf.head()->data() + d->stdinBufRead, + qMin( 8192, int(d->stdinBuf.head()->size() - d->stdinBufRead) ), + &written, 0 ) ) { + d->lookup->start( 100 ); + return; + } + d->stdinBufRead += written; + if ( d->stdinBufRead == (DWORD)d->stdinBuf.head()->size() ) { + d->stdinBufRead = 0; + delete d->stdinBuf.dequeue(); + if ( wroteToStdinConnected && d->stdinBuf.isEmpty() ) + emit wroteToStdin(); + } + } +} + +void Q3Process::flushStdin() +{ + socketWrite( 0 ); +} + +/* + Use a timer for polling misc. stuff. +*/ +void Q3Process::timeout() +{ + // Disable the timer temporary since one of the slots that are connected to + // the readyRead...(), etc. signals might trigger recursion if + // processEvents() is called. + d->lookup->stop(); + + // try to write pending data to stdin + if ( !d->stdinBuf.isEmpty() ) + socketWrite( 0 ); + + if ( ioRedirection ) { + socketRead( 1 ); // try stdout + socketRead( 2 ); // try stderr + } + + if ( isRunning() ) { + // enable timer again, if needed + if ( !d->stdinBuf.isEmpty() || ioRedirection || notifyOnExit ) + d->lookup->start( 100 ); + } else if ( notifyOnExit ) { + emit processExited(); + } +} + +/* + read on the pipe +*/ +uint Q3Process::readStddev( HANDLE dev, char *buf, uint bytes ) +{ + if ( bytes > 0 ) { + ulong r; + if ( ReadFile( dev, buf, bytes, &r, 0 ) ) + return r; + } + return 0; +} + +/* + Used by connectNotify() and disconnectNotify() to change the value of + ioRedirection (and related behaviour) +*/ +void Q3Process::setIoRedirection( bool value ) +{ + ioRedirection = value; + if ( !ioRedirection && !notifyOnExit ) + d->lookup->stop(); + if ( ioRedirection ) { + if ( isRunning() ) + d->lookup->start( 100 ); + } +} + +/* + Used by connectNotify() and disconnectNotify() to change the value of + notifyOnExit (and related behaviour) +*/ +void Q3Process::setNotifyOnExit( bool value ) +{ + notifyOnExit = value; + if ( !ioRedirection && !notifyOnExit ) + d->lookup->stop(); + if ( notifyOnExit ) { + if ( isRunning() ) + d->lookup->start( 100 ); + } +} + +/* + Used by connectNotify() and disconnectNotify() to change the value of + wroteToStdinConnected (and related behaviour) +*/ +void Q3Process::setWroteStdinConnected( bool value ) +{ + wroteToStdinConnected = value; +} + +Q3Process::PID Q3Process::processIdentifier() +{ + return d->pid; +} + +QT_END_NAMESPACE + +#endif // QT_NO_PROCESS diff --git a/src/qt3support/other/qiconset.h b/src/qt3support/other/qiconset.h new file mode 100644 index 0000000..5bfc902 --- /dev/null +++ b/src/qt3support/other/qiconset.h @@ -0,0 +1,48 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtGui/qicon.h> + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3Support) + +QT_END_NAMESPACE diff --git a/src/qt3support/other/qt_compat_pch.h b/src/qt3support/other/qt_compat_pch.h new file mode 100644 index 0000000..2b03003 --- /dev/null +++ b/src/qt3support/other/qt_compat_pch.h @@ -0,0 +1,66 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the Qt3Support 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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +/* + * This is a precompiled header file for use in Xcode / Mac GCC / + * GCC >= 3.4 / VC to greatly speed the building of Qt. It may also be + * of use to people developing their own project, but it is probably + * better to define your own header. Use of this header is currently + * UNSUPPORTED. + */ + +#if defined __cplusplus +#include <qapplication.h> +#include <qbitmap.h> +#include <qcursor.h> +#include <qdesktopwidget.h> +#include <qevent.h> +#include <qimage.h> +#include <qlayout.h> +#include <qpainter.h> +#include <qpixmap.h> +#include <qstring.h> +#include <qstyle.h> +#include <qtimer.h> +#include <qwidget.h> + +#include <stdlib.h> +#endif |