diff options
Diffstat (limited to 'source/l')
| -rw-r--r-- | source/l/qt5/patches/24.diff | 585 | ||||
| -rwxr-xr-x | source/l/qt5/qt5.SlackBuild | 11 | ||||
| -rw-r--r-- | source/l/svgalib/svgalib-1.9.21-demos.patch | 431 | ||||
| -rw-r--r-- | source/l/svgalib/svgalib-1.9.25.no_asm.patch | 11 | ||||
| -rwxr-xr-x | source/l/svgalib/svgalib.SlackBuild | 10 |
5 files changed, 1042 insertions, 6 deletions
diff --git a/source/l/qt5/patches/24.diff b/source/l/qt5/patches/24.diff new file mode 100644 index 000000000..5921881b7 --- /dev/null +++ b/source/l/qt5/patches/24.diff @@ -0,0 +1,585 @@ +diff --git a/src/client/qwaylanddisplay.cpp b/src/client/qwaylanddisplay.cpp +index ea344c61c3a4643f7c725a6287f20d742b210d24..a7ce280a5df538917758e50ba8d2ee117378d546 100644 +--- a/src/client/qwaylanddisplay.cpp ++++ b/src/client/qwaylanddisplay.cpp +@@ -85,10 +85,203 @@ + + #include <errno.h> + ++#include <tuple> // for std::tie ++ ++static void checkWaylandError(struct wl_display *display) ++{ ++ int ecode = wl_display_get_error(display); ++ if ((ecode == EPIPE || ecode == ECONNRESET)) { ++ // special case this to provide a nicer error ++ qWarning("The Wayland connection broke. Did the Wayland compositor die?"); ++ } else { ++ qWarning("The Wayland connection experienced a fatal error: %s", strerror(ecode)); ++ } ++ _exit(1); ++} ++ + QT_BEGIN_NAMESPACE + + namespace QtWaylandClient { + ++class EventThread : public QThread ++{ ++ Q_OBJECT ++public: ++ enum OperatingMode { ++ EmitToDispatch, // Emit the signal, allow dispatching in a differnt thread. ++ SelfDispatch, // Dispatch the events inside this thread. ++ }; ++ ++ EventThread(struct wl_display * wl, struct wl_event_queue * ev_queue, ++ OperatingMode mode) ++ : m_fd(wl_display_get_fd(wl)) ++ , m_pipefd{ -1, -1 } ++ , m_wldisplay(wl) ++ , m_wlevqueue(ev_queue) ++ , m_mode(mode) ++ , m_reading(true) ++ , m_quitting(false) ++ { ++ setObjectName(QStringLiteral("WaylandEventThread")); ++ } ++ ++ void readAndDispatchEvents() ++ { ++ /* ++ * Dispatch pending events and flush the requests at least once. If the event thread ++ * is not reading, try to call _prepare_read() to allow the event thread to poll(). ++ * If that fails, re-try dispatch & flush again until _prepare_read() is successful. ++ * ++ * This allow any call to readAndDispatchEvents() to start event thread's polling, ++ * not only the one issued from event thread's waitForReading(), which means functions ++ * called from dispatch_pending() can safely spin an event loop. ++ */ ++ for (;;) { ++ if (dispatchQueuePending() < 0) { ++ checkWaylandError(m_wldisplay); ++ return; ++ } ++ ++ wl_display_flush(m_wldisplay); ++ ++ // We have to check if event thread is reading every time we dispatch ++ // something, as that may recursively call this function. ++ if (m_reading.loadAcquire()) ++ break; ++ ++ if (prepareReadQueue() == 0) { ++ QMutexLocker l(&m_mutex); ++ m_reading.storeRelease(true); ++ m_cond.wakeOne(); ++ break; ++ } ++ } ++ } ++ ++ void stop() ++ { ++ // We have to both write to the pipe and set the flag, as the thread may be ++ // either in the poll() or waiting for _prepare_read(). ++ if (m_pipefd[1] != -1 && write(m_pipefd[1], "\0", 1) == -1) ++ qWarning("Failed to write to the pipe: %s.", strerror(errno)); ++ ++ { ++ QMutexLocker l(&m_mutex); ++ m_quitting = true; ++ m_cond.wakeOne(); ++ } ++ ++ wait(); ++ } ++ ++Q_SIGNALS: ++ void needReadAndDispatch(); ++ ++protected: ++ void run() override ++ { ++ // we use this pipe to make the loop exit otherwise if we simply used a flag on the loop condition, if stop() gets ++ // called while poll() is blocking the thread will never quit since there are no wayland messages coming anymore. ++ struct Pipe ++ { ++ Pipe(int *fds) ++ : fds(fds) ++ { ++ if (qt_safe_pipe(fds) != 0) ++ qWarning("Pipe creation failed. Quitting may hang."); ++ } ++ ~Pipe() ++ { ++ if (fds[0] != -1) { ++ close(fds[0]); ++ close(fds[1]); ++ } ++ } ++ ++ int *fds; ++ } pipe(m_pipefd); ++ ++ // Make the main thread call wl_prepare_read(), dispatch the pending messages and flush the ++ // outbound ones. Wait until it's done before proceeding, unless we're told to quit. ++ while (waitForReading()) { ++ pollfd fds[2] = { { m_fd, POLLIN, 0 }, { m_pipefd[0], POLLIN, 0 } }; ++ poll(fds, 2, -1); ++ ++ if (fds[1].revents & POLLIN) { ++ // we don't really care to read the byte that was written here since we're closing down ++ wl_display_cancel_read(m_wldisplay); ++ break; ++ } ++ ++ if (fds[0].revents & POLLIN) ++ wl_display_read_events(m_wldisplay); ++ // The polll was succesfull and the event thread did the wl_display_read_events(). On the next iteration of the loop ++ // the event sent to the main thread will cause it to dispatch the messages just read, unless the loop exits in which ++ // case we don't care anymore about them. ++ else ++ wl_display_cancel_read(m_wldisplay); ++ } ++ } ++ ++private: ++ bool waitForReading() ++ { ++ Q_ASSERT(QThread::currentThread() == this); ++ ++ m_reading.storeRelease(false); ++ ++ if (m_mode == SelfDispatch) { ++ readAndDispatchEvents(); ++ } else { ++ Q_EMIT needReadAndDispatch(); ++ ++ QMutexLocker lock(&m_mutex); ++ // m_reading might be set from our emit or some other invocation of ++ // readAndDispatchEvents(). ++ while (!m_reading.loadRelaxed() && !m_quitting) ++ m_cond.wait(&m_mutex); ++ } ++ ++ return !m_quitting; ++ } ++ ++ int dispatchQueuePending() ++ { ++ if (m_wlevqueue) ++ return wl_display_dispatch_queue_pending(m_wldisplay, m_wlevqueue); ++ else ++ return wl_display_dispatch_pending(m_wldisplay); ++ } ++ ++ int prepareReadQueue() ++ { ++ if (m_wlevqueue) ++ return wl_display_prepare_read_queue(m_wldisplay, m_wlevqueue); ++ else ++ return wl_display_prepare_read(m_wldisplay); ++ } ++ ++ int m_fd; ++ int m_pipefd[2]; ++ wl_display *m_wldisplay; ++ wl_event_queue *m_wlevqueue; ++ OperatingMode m_mode; ++ ++ /* Concurrency note when operating in EmitToDispatch mode: ++ * m_reading is set to false inside event thread's waitForReading(), and is ++ * set to true inside main thread's readAndDispatchEvents(). ++ * The lock is not taken when setting m_reading to false, as the main thread ++ * is not actively waiting for it to turn false. However, the lock is taken ++ * inside readAndDispatchEvents() before setting m_reading to true, ++ * as the event thread is actively waiting for it under the wait condition. ++ */ ++ ++ QAtomicInteger<bool> m_reading; ++ bool m_quitting; ++ QMutex m_mutex; ++ QWaitCondition m_cond; ++}; ++ + Q_LOGGING_CATEGORY(lcQpaWayland, "qt.qpa.wayland"); // for general (uncategorized) Wayland platform logging + + struct wl_surface *QWaylandDisplay::createSurface(void *handle) +@@ -158,17 +351,16 @@ QWaylandDisplay::QWaylandDisplay(QWaylandIntegration *waylandIntegration) + if (!mXkbContext) + qCWarning(lcQpaWayland, "failed to create xkb context"); + #endif +- +- forceRoundTrip(); +- +- if (!mWaitingScreens.isEmpty()) { +- // Give wl_output.done and zxdg_output_v1.done events a chance to arrive +- forceRoundTrip(); +- } + } + + QWaylandDisplay::~QWaylandDisplay(void) + { ++ if (m_eventThread) ++ m_eventThread->stop(); ++ ++ if (m_frameEventQueueThread) ++ m_frameEventQueueThread->stop(); ++ + if (mSyncCallback) + wl_callback_destroy(mSyncCallback); + +@@ -189,6 +381,18 @@ QWaylandDisplay::~QWaylandDisplay(void) + wl_display_disconnect(mDisplay); + } + ++// Steps which is called just after constructor. This separates registry_global() out of the constructor ++// so that factory functions in integration can be overridden. ++void QWaylandDisplay::initialize() ++{ ++ forceRoundTrip(); ++ ++ if (!mWaitingScreens.isEmpty()) { ++ // Give wl_output.done and zxdg_output_v1.done events a chance to arrive ++ forceRoundTrip(); ++ } ++} ++ + void QWaylandDisplay::ensureScreen() + { + if (!mScreens.empty() || mPlaceholderScreen) +@@ -203,98 +407,37 @@ void QWaylandDisplay::ensureScreen() + + void QWaylandDisplay::checkError() const + { +- int ecode = wl_display_get_error(mDisplay); +- if ((ecode == EPIPE || ecode == ECONNRESET)) { +- // special case this to provide a nicer error +- qWarning("The Wayland connection broke. Did the Wayland compositor die?"); +- } else { +- qWarning("The Wayland connection experienced a fatal error: %s", strerror(ecode)); +- } +- _exit(1); ++ checkWaylandError(mDisplay); + } + ++// Called in main thread, either from queued signal or directly. + void QWaylandDisplay::flushRequests() + { +- if (wl_display_prepare_read(mDisplay) == 0) { +- wl_display_read_events(mDisplay); +- } +- +- if (wl_display_dispatch_pending(mDisplay) < 0) +- checkError(); +- +- { +- QReadLocker locker(&m_frameQueueLock); +- for (const FrameQueue &q : mExternalQueues) { +- QMutexLocker locker(q.mutex); +- while (wl_display_prepare_read_queue(mDisplay, q.queue) != 0) +- wl_display_dispatch_queue_pending(mDisplay, q.queue); +- wl_display_read_events(mDisplay); +- wl_display_dispatch_queue_pending(mDisplay, q.queue); +- } +- } +- +- wl_display_flush(mDisplay); +-} +- +-void QWaylandDisplay::blockingReadEvents() +-{ +- if (wl_display_dispatch(mDisplay) < 0) +- checkError(); +-} +- +-void QWaylandDisplay::destroyFrameQueue(const QWaylandDisplay::FrameQueue &q) +-{ +- QWriteLocker locker(&m_frameQueueLock); +- auto it = std::find_if(mExternalQueues.begin(), +- mExternalQueues.end(), +- [&q] (const QWaylandDisplay::FrameQueue &other){ return other.queue == q.queue; }); +- Q_ASSERT(it != mExternalQueues.end()); +- mExternalQueues.erase(it); +- if (q.queue != nullptr) +- wl_event_queue_destroy(q.queue); +- delete q.mutex; ++ m_eventThread->readAndDispatchEvents(); + } + +-QWaylandDisplay::FrameQueue QWaylandDisplay::createFrameQueue() ++// We have to wait until we have an eventDispatcher before creating the eventThread, ++// otherwise forceRoundTrip() may block inside _events_read() because eventThread is ++// polling. ++void QWaylandDisplay::initEventThread() + { +- QWriteLocker locker(&m_frameQueueLock); +- FrameQueue q{createEventQueue()}; +- mExternalQueues.append(q); +- return q; +-} ++ m_eventThread.reset( ++ new EventThread(mDisplay, /* default queue */ nullptr, EventThread::EmitToDispatch)); ++ connect(m_eventThread.get(), &EventThread::needReadAndDispatch, this, ++ &QWaylandDisplay::flushRequests, Qt::QueuedConnection); ++ m_eventThread->start(); + +-wl_event_queue *QWaylandDisplay::createEventQueue() +-{ +- return wl_display_create_queue(mDisplay); ++ // wl_display_disconnect() free this. ++ m_frameEventQueue = wl_display_create_queue(mDisplay); ++ m_frameEventQueueThread.reset( ++ new EventThread(mDisplay, m_frameEventQueue, EventThread::SelfDispatch)); ++ m_frameEventQueueThread->start(); + } + +-void QWaylandDisplay::dispatchQueueWhile(wl_event_queue *queue, std::function<bool ()> condition, int timeout) ++void QWaylandDisplay::blockingReadEvents() + { +- if (!condition()) +- return; +- +- QElapsedTimer timer; +- timer.start(); +- struct pollfd pFd = qt_make_pollfd(wl_display_get_fd(mDisplay), POLLIN); +- while (timeout == -1 || timer.elapsed() < timeout) { +- while (wl_display_prepare_read_queue(mDisplay, queue) != 0) +- wl_display_dispatch_queue_pending(mDisplay, queue); +- +- wl_display_flush(mDisplay); +- +- const int remaining = qMax(timeout - timer.elapsed(), 0ll); +- const int pollTimeout = timeout == -1 ? -1 : remaining; +- if (qt_poll_msecs(&pFd, 1, pollTimeout) > 0) +- wl_display_read_events(mDisplay); +- else +- wl_display_cancel_read(mDisplay); +- +- if (wl_display_dispatch_queue_pending(mDisplay, queue) < 0) +- checkError(); +- +- if (!condition()) +- break; +- } ++ if (wl_display_dispatch(mDisplay) < 0) ++ checkWaylandError(mDisplay); + } + + QWaylandScreen *QWaylandDisplay::screenForOutput(struct wl_output *output) const +@@ -669,4 +812,6 @@ QWaylandCursorTheme *QWaylandDisplay::loadCursorTheme(const QString &name, int p + + } // namespace QtWaylandClient + ++#include "qwaylanddisplay.moc" ++ + QT_END_NAMESPACE +diff --git a/src/client/qwaylanddisplay_p.h b/src/client/qwaylanddisplay_p.h +index 09a1736a267d2816873667e9f1ecb4f4892f0ed0..42bc661d3064d770aa9fde8bd62ecdbbc89732a2 100644 +--- a/src/client/qwaylanddisplay_p.h ++++ b/src/client/qwaylanddisplay_p.h +@@ -109,6 +109,7 @@ class QWaylandSurface; + class QWaylandShellIntegration; + class QWaylandCursor; + class QWaylandCursorTheme; ++class EventThread; + + typedef void (*RegistryListener)(void *data, + struct wl_registry *registry, +@@ -120,15 +121,11 @@ class Q_WAYLAND_CLIENT_EXPORT QWaylandDisplay : public QObject, public QtWayland + Q_OBJECT + + public: +- struct FrameQueue { +- FrameQueue(wl_event_queue *q = nullptr) : queue(q), mutex(new QMutex) {} +- wl_event_queue *queue; +- QMutex *mutex; +- }; +- + QWaylandDisplay(QWaylandIntegration *waylandIntegration); + ~QWaylandDisplay(void) override; + ++ void initialize(); ++ + #if QT_CONFIG(xkbcommon) + struct xkb_context *xkbContext() const { return mXkbContext.get(); } + #endif +@@ -210,12 +207,11 @@ public: + void handleKeyboardFocusChanged(QWaylandInputDevice *inputDevice); + void handleWindowDestroyed(QWaylandWindow *window); + +- wl_event_queue *createEventQueue(); +- FrameQueue createFrameQueue(); +- void destroyFrameQueue(const FrameQueue &q); +- void dispatchQueueWhile(wl_event_queue *queue, std::function<bool()> condition, int timeout = -1); ++ wl_event_queue *frameEventQueue() { return m_frameEventQueue; }; + + bool isKeyboardAvailable() const; ++ ++ void initEventThread(); + public slots: + void blockingReadEvents(); + void flushRequests(); +@@ -238,6 +234,9 @@ private: + }; + + struct wl_display *mDisplay = nullptr; ++ QScopedPointer<EventThread> m_eventThread; ++ wl_event_queue *m_frameEventQueue = nullptr; ++ QScopedPointer<EventThread> m_frameEventQueueThread; + QtWayland::wl_compositor mCompositor; + QScopedPointer<QWaylandShm> mShm; + QList<QWaylandScreen *> mWaitingScreens; +@@ -274,11 +273,9 @@ private: + QWaylandInputDevice *mLastInputDevice = nullptr; + QPointer<QWaylandWindow> mLastInputWindow; + QPointer<QWaylandWindow> mLastKeyboardFocus; +- QVector<QWaylandWindow *> mActiveWindows; +- QVector<FrameQueue> mExternalQueues; ++ QList<QWaylandWindow *> mActiveWindows; + struct wl_callback *mSyncCallback = nullptr; + static const wl_callback_listener syncCallbackListener; +- QReadWriteLock m_frameQueueLock; + + bool mClientSideInputContextRequested = !QPlatformInputContextFactory::requested().isNull(); + +diff --git a/src/client/qwaylandintegration.cpp b/src/client/qwaylandintegration.cpp +index e5e7dd42c9b0145f4c9852f7e15dcc83106c321d..3b876047293887d17eeb28819c7386ded9e1f131 100644 +--- a/src/client/qwaylandintegration.cpp ++++ b/src/client/qwaylandintegration.cpp +@@ -192,14 +192,18 @@ QAbstractEventDispatcher *QWaylandIntegration::createEventDispatcher() const + + void QWaylandIntegration::initialize() + { ++ mDisplay->initEventThread(); ++ ++ // Call after eventDispatcher is fully connected, for QWaylandDisplay::forceRoundTrip() ++ mDisplay->initialize(); ++ ++ // But the aboutToBlock() and awake() should be connected after initializePlatform(). ++ // Otherwise the connected flushRequests() may consumes up all events before processEvents starts to wait, ++ // so that processEvents(QEventLoop::WaitForMoreEvents) may be blocked in the forceRoundTrip(). + QAbstractEventDispatcher *dispatcher = QGuiApplicationPrivate::eventDispatcher; + QObject::connect(dispatcher, SIGNAL(aboutToBlock()), mDisplay.data(), SLOT(flushRequests())); + QObject::connect(dispatcher, SIGNAL(awake()), mDisplay.data(), SLOT(flushRequests())); + +- int fd = wl_display_get_fd(mDisplay->wl_display()); +- QSocketNotifier *sn = new QSocketNotifier(fd, QSocketNotifier::Read, mDisplay.data()); +- QObject::connect(sn, SIGNAL(activated(QSocketDescriptor)), mDisplay.data(), SLOT(flushRequests())); +- + // Qt does not support running with no screens + mDisplay->ensureScreen(); + } +diff --git a/src/client/qwaylandwindow.cpp b/src/client/qwaylandwindow.cpp +index 1597f67e63ae7834ded50e25b0acf86b71abcd73..7de19a742b6d3f6a3ce0955f59a5bf2879d29c9e 100644 +--- a/src/client/qwaylandwindow.cpp ++++ b/src/client/qwaylandwindow.cpp +@@ -76,7 +76,6 @@ QWaylandWindow *QWaylandWindow::mMouseGrab = nullptr; + QWaylandWindow::QWaylandWindow(QWindow *window, QWaylandDisplay *display) + : QPlatformWindow(window) + , mDisplay(display) +- , mFrameQueue(mDisplay->createFrameQueue()) + , mResizeAfterSwap(qEnvironmentVariableIsSet("QT_WAYLAND_RESIZE_AFTER_SWAP")) + { + { +@@ -95,8 +94,6 @@ QWaylandWindow::QWaylandWindow(QWindow *window, QWaylandDisplay *display) + + QWaylandWindow::~QWaylandWindow() + { +- mDisplay->destroyFrameQueue(mFrameQueue); +- + delete mWindowDecoration; + + if (mSurface) +@@ -635,6 +632,8 @@ const wl_callback_listener QWaylandWindow::callbackListener = { + + void QWaylandWindow::handleFrameCallback() + { ++ QMutexLocker locker(&mFrameSyncMutex); ++ + mWaitingForFrameCallback = false; + mFrameCallbackElapsedTimer.invalidate(); + +@@ -656,12 +655,16 @@ void QWaylandWindow::handleFrameCallback() + mWaitingForUpdateDelivery = true; + QMetaObject::invokeMethod(this, doHandleExpose, Qt::QueuedConnection); + } ++ ++ mFrameSyncWait.notify_all(); + } + + bool QWaylandWindow::waitForFrameSync(int timeout) + { +- QMutexLocker locker(mFrameQueue.mutex); +- mDisplay->dispatchQueueWhile(mFrameQueue.queue, [&]() { return mWaitingForFrameCallback; }, timeout); ++ QMutexLocker locker(&mFrameSyncMutex); ++ ++ QDeadlineTimer deadline(timeout); ++ while (mWaitingForFrameCallback && mFrameSyncWait.wait(&mFrameSyncMutex, deadline)) { } + + if (mWaitingForFrameCallback) { + qCDebug(lcWaylandBackingstore) << "Didn't receive frame callback in time, window should now be inexposed"; +@@ -1157,8 +1160,11 @@ void QWaylandWindow::requestUpdate() + Q_ASSERT(hasPendingUpdateRequest()); // should be set by QPA + + // If we have a frame callback all is good and will be taken care of there +- if (mWaitingForFrameCallback) +- return; ++ { ++ QMutexLocker locker(&mFrameSyncMutex); ++ if (mWaitingForFrameCallback) ++ return; ++ } + + // If we've already called deliverUpdateRequest(), but haven't seen any attach+commit/swap yet + // This is a somewhat redundant behavior and might indicate a bug in the calling code, so log +@@ -1171,7 +1177,12 @@ void QWaylandWindow::requestUpdate() + // so use invokeMethod to delay the delivery a bit. + QMetaObject::invokeMethod(this, [this] { + // Things might have changed in the meantime +- if (hasPendingUpdateRequest() && !mWaitingForFrameCallback) ++ { ++ QMutexLocker locker(&mFrameSyncMutex); ++ if (mWaitingForFrameCallback) ++ return; ++ } ++ if (hasPendingUpdateRequest()) + deliverUpdateRequest(); + }, Qt::QueuedConnection); + } +@@ -1191,9 +1202,10 @@ void QWaylandWindow::handleUpdate() + if (!mSurface) + return; + +- QMutexLocker locker(mFrameQueue.mutex); ++ QMutexLocker locker(&mFrameSyncMutex); ++ + struct ::wl_surface *wrappedSurface = reinterpret_cast<struct ::wl_surface *>(wl_proxy_create_wrapper(mSurface->object())); +- wl_proxy_set_queue(reinterpret_cast<wl_proxy *>(wrappedSurface), mFrameQueue.queue); ++ wl_proxy_set_queue(reinterpret_cast<wl_proxy *>(wrappedSurface), mDisplay->frameEventQueue()); + mFrameCallback = wl_surface_frame(wrappedSurface); + wl_proxy_wrapper_destroy(wrappedSurface); + wl_callback_add_listener(mFrameCallback, &QWaylandWindow::callbackListener, this); +@@ -1203,6 +1215,8 @@ void QWaylandWindow::handleUpdate() + // Start a timer for handling the case when the compositor stops sending frame callbacks. + if (mFrameCallbackTimeout > 0) { + QMetaObject::invokeMethod(this, [this] { ++ QMutexLocker locker(&mFrameSyncMutex); ++ + if (mWaitingForFrameCallback) { + if (mFrameCallbackCheckIntervalTimerId < 0) + mFrameCallbackCheckIntervalTimerId = startTimer(mFrameCallbackTimeout); +diff --git a/src/client/qwaylandwindow_p.h b/src/client/qwaylandwindow_p.h +index e06879620c3d033f093b0866f018ec80a72a97c3..d45980a80e9ecc9c5003fa2144de63e6337bda8a 100644 +--- a/src/client/qwaylandwindow_p.h ++++ b/src/client/qwaylandwindow_p.h +@@ -232,7 +232,7 @@ protected: + int mFrameCallbackCheckIntervalTimerId = -1; + QElapsedTimer mFrameCallbackElapsedTimer; + struct ::wl_callback *mFrameCallback = nullptr; +- QWaylandDisplay::FrameQueue mFrameQueue; ++ QMutex mFrameSyncMutex; + QWaitCondition mFrameSyncWait; + + // True when we have called deliverRequestUpdate, but the client has not yet attached a new buffer diff --git a/source/l/qt5/qt5.SlackBuild b/source/l/qt5/qt5.SlackBuild index b17df2fd5..d9b2b3942 100755 --- a/source/l/qt5/qt5.SlackBuild +++ b/source/l/qt5/qt5.SlackBuild @@ -1,6 +1,6 @@ #!/bin/sh -# Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Patrick J. Volkerding, Sebeka, MN, USA +# Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Patrick J. Volkerding, Sebeka, MN, USA # All rights reserved. # # Redistribution and use of this script, with or without modification, is @@ -31,7 +31,7 @@ cd $(dirname $0) ; CWD=$(pwd) PKGNAM=qt5 VERSION=$(ls qt-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev) -BUILD=${BUILD:-1} +BUILD=${BUILD:-2} PKGSRC=$(echo $VERSION | cut -d - -f 1) PKGVER=$(echo $VERSION | tr - _) @@ -148,6 +148,13 @@ cd qtwebengine zcat $CWD/patches/qtwebengine-everywhere-src-5.15.2-%231904652.patch.gz | patch -p1 --verbose || exit 1 cd - 1>/dev/null +# Apply upstream patch to move the wayland socket polling to a separate event +# thread. This greatly improves the behavior of Plasma Wayland sessions, fixing +# (for example) stuttering that was occuring on multimedia applications. +cd qtwayland + zcat $CWD/patches/24.diff.gz | patch -p1 --verbose || exit 1 +cd - 1>/dev/null + # If PulseAudio is not found, use the _alsa $TAG and disable it in the build: if ! pkg-config --exists libpulse 2>/dev/null ; then PULSEAUDIO_OPTION="-no-pulseaudio -no-webengine-pulseaudio" diff --git a/source/l/svgalib/svgalib-1.9.21-demos.patch b/source/l/svgalib/svgalib-1.9.21-demos.patch new file mode 100644 index 000000000..7da772edb --- /dev/null +++ b/source/l/svgalib/svgalib-1.9.21-demos.patch @@ -0,0 +1,431 @@ +--- svgalib-1.9.21/demos/testgl.c.demos 2002-04-03 09:31:14.000000000 +0200 ++++ svgalib-1.9.21/demos/testgl.c 2005-07-01 20:51:55.000000000 +0200 +@@ -184,7 +184,7 @@ + + if (!vga_hasmode(VGAMODE)) { + printf("Mode not available.\n"); +- exit(-1); ++ return -1; + } + VIRTUAL = 0; /* No virtual screen. */ + if (vga_getmodeinfo(VGAMODE)->colors == 16 || +@@ -224,5 +224,5 @@ + if (VIRTUAL) + gl_freecontext(backscreen); + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/vgatweak.c.demos 2000-08-06 12:20:02.000000000 +0200 ++++ svgalib-1.9.21/demos/vgatweak.c 2005-07-01 20:51:55.000000000 +0200 +@@ -124,7 +124,7 @@ + testmode(mode); + else { + printf("Error: Video mode not supported by driver\n"); +- exit(-1); ++ return -1; + } + + return 0; +--- svgalib-1.9.21/demos/linearfork.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/linearfork.c 2005-07-01 20:51:55.000000000 +0200 +@@ -82,7 +82,7 @@ + + if (!vga_hasmode(vgamode)) { + printf("Mode not available.\n"); +- exit(1); ++ return 1; + } + vga_setmode(vgamode); + vga_setlinearaddressing(); +@@ -95,7 +95,7 @@ + /* purposes. */ + if (keyboard_init()) { + printf("Could not initialize keyboard.\n"); +- exit(1); ++ return 1; + } + /* Translate to 4 keypad cursor keys, and unify enter key. */ + keyboard_translatekeys(TRANSLATE_CURSORKEYS | TRANSLATE_KEYPADENTER | +@@ -161,5 +161,5 @@ + keyboard_close(); /* Don't forget this! */ + + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/bg_test.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/bg_test.c 2005-07-01 20:51:55.000000000 +0200 +@@ -9,6 +9,7 @@ + #include <stdio.h> + #include <stdlib.h> + #include <unistd.h> ++#include <string.h> + #include <strings.h> + #include <vga.h> + #include <vgagl.h> +--- svgalib-1.9.21/demos/accel.c.demos 2002-04-03 09:30:23.000000000 +0200 ++++ svgalib-1.9.21/demos/accel.c 2005-07-01 20:51:55.000000000 +0200 +@@ -97,7 +97,7 @@ + + if (accelfuncs == 0) { + printf("No acceleration supported.\n"); +- exit(0); ++ return 1; + } + printf("Accelflags: 0x%08X\n", accelfuncs); + +@@ -292,7 +292,7 @@ + ); + } + vga_setmode(TEXT); +- exit(-1); ++ return 0; + } + + +--- svgalib-1.9.21/demos/vgatest.c.demos 2005-01-27 11:34:16.000000000 +0100 ++++ svgalib-1.9.21/demos/vgatest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -275,7 +275,7 @@ + + if (mode < 1 || mode > GLASTMODE) { + printf("Error: Mode number out of range \n"); +- exit(-1); ++ return -1; + } + } + if (vga_hasmode(mode)) { +@@ -285,7 +285,7 @@ + } + } else { + printf("Error: Video mode not supported by driver\n"); +- exit(-1); ++ return -1; + } + + vga_setmode(TEXT); +--- svgalib-1.9.21/demos/printftest.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/printftest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -44,7 +44,7 @@ + + if (!vga_hasmode(vgamode)) { + printf("Mode not available.\n"); +- exit(1); ++ return 1; + } + + vga_setmode(vgamode); +@@ -68,5 +68,5 @@ + + vga_setmode(TEXT); + +- exit(retval); ++ return retval; + } +--- svgalib-1.9.21/demos/fun.c.demos 2002-07-20 18:33:54.000000000 +0200 ++++ svgalib-1.9.21/demos/fun.c 2005-07-01 20:51:55.000000000 +0200 +@@ -13,6 +13,7 @@ + #include <unistd.h> + #include <string.h> + #include <time.h> ++#include <string.h> + #include <vga.h> + #include <vgagl.h> + +--- svgalib-1.9.21/demos/bankspeed.c.demos 2002-04-03 09:31:22.000000000 +0200 ++++ svgalib-1.9.21/demos/bankspeed.c 2005-07-01 20:51:55.000000000 +0200 +@@ -125,7 +125,7 @@ + + if (!vga_hasmode(VGAMODE)) { + printf("Mode not available.\n"); +- exit(-1); ++ return -1; + } + VIRTUAL = 0; /* No virtual screen. */ + if (vga_getmodeinfo(VGAMODE)->colors == 16 || +@@ -165,5 +165,5 @@ + t2=clock(); + printf("total:%1.2f sec\n",(1.0*t2-t1)/CLOCKS_PER_SEC); + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/eventtest.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/eventtest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -3,6 +3,7 @@ + #include <stdlib.h> + #include <stdio.h> + #include <unistd.h> ++#include <time.h> + #include <sys/time.h> + #include <sys/types.h> + #include <vga.h> +@@ -254,5 +255,5 @@ + keyboard_close(); /* Don't forget this! */ + #endif + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/svidtune.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/svidtune.c 2005-07-01 20:51:55.000000000 +0200 +@@ -48,7 +48,7 @@ + + if (!vga_hasmode(vgamode)) { + printf("Mode not available.\n"); +- exit(1); ++ return 1; + } + + vga_setmode(vgamode); +@@ -176,5 +176,5 @@ + + vga_setmode(TEXT); + +- exit(retval); ++ return retval; + } +--- svgalib-1.9.21/demos/keytest.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/keytest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -38,7 +38,7 @@ + + if (!vga_hasmode(vgamode)) { + printf("Mode not available.\n"); +- exit(1); ++ return 1; + } + printf("\nWARNING: This program will set the keyboard to RAW mode.\n" + "The keyboard routines in svgalib have not been tested\n" +@@ -61,7 +61,7 @@ + /* purposes. */ + if (keyboard_init()) { + printf("Could not initialize keyboard.\n"); +- exit(1); ++ return 1; + } + /* Translate to 4 keypad cursor keys, and unify enter key. */ + keyboard_translatekeys(TRANSLATE_CURSORKEYS | TRANSLATE_KEYPADENTER | +@@ -126,5 +126,5 @@ + + keyboard_close(); /* Don't forget this! */ + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/scrolltest.c.demos 2000-01-12 21:03:39.000000000 +0100 ++++ svgalib-1.9.21/demos/scrolltest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -304,5 +304,5 @@ + demo3(); + + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/forktest.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/forktest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -82,7 +82,7 @@ + + if (!vga_hasmode(vgamode)) { + printf("Mode not available.\n"); +- exit(1); ++ return 1; + } + vga_setmode(vgamode); + gl_setcontextvga(vgamode); +@@ -94,7 +94,7 @@ + /* purposes. */ + if (keyboard_init()) { + printf("Could not initialize keyboard.\n"); +- exit(1); ++ return 1; + } + /* Translate to 4 keypad cursor keys, and unify enter key. */ + keyboard_translatekeys(TRANSLATE_CURSORKEYS | TRANSLATE_KEYPADENTER | +@@ -160,5 +160,5 @@ + keyboard_close(); /* Don't forget this! */ + + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/mjoytest.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/mjoytest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -196,7 +196,7 @@ + + if (!vga_hasmode(vgamode)) { + printf("Mode not available.\n"); +- exit(-1); ++ return -1; + } + + puts("In the demo, press\n" +@@ -286,6 +286,6 @@ + printf("Shutting down.\n"); + + vga_setmode(TEXT); +- exit(0); ++ return 0; + } + +--- svgalib-1.9.21/demos/speedtest.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/speedtest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -1,4 +1,3 @@ +- + #include <unistd.h> + #include <stdlib.h> + #include <stdio.h> +@@ -308,5 +307,5 @@ + speed(); + + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/linearspeed.c.demos 2003-11-07 10:26:02.000000000 +0100 ++++ svgalib-1.9.21/demos/linearspeed.c 2005-07-01 20:51:55.000000000 +0200 +@@ -418,5 +418,5 @@ + if(!fast)sysmem_speed(); + + vga_setmode(TEXT); +- exit(0); ++ return 0; + } +--- svgalib-1.9.21/demos/testlinear.c.demos 2004-09-16 19:56:12.000000000 +0200 ++++ svgalib-1.9.21/demos/testlinear.c 2005-07-01 20:51:55.000000000 +0200 +@@ -11,7 +11,7 @@ + #include <string.h> + #include <vga.h> + #include <time.h> +-#include "../src/libvga.h" ++#include "libvga.h" + + + #define USE_LINEAR_ADDRESSING +@@ -66,7 +66,7 @@ + if (!(argc == 2 && strcmp(argv[1], "--force") == 0)) + if (!(vga_getmodeinfo(vga_getdefaultmode())->flags & CAPABLE_LINEAR)) { + printf("Linear addressing not supported for this chipset.\n"); +- exit(1); ++ return 1; + } + vga_init(); + vga_setmode(vga_getdefaultmode()); +@@ -75,7 +75,7 @@ + if (vga_setlinearaddressing() == -1) { + vga_setmode(TEXT); + printf("Could not set linear addressing.\n"); +- exit(-1); ++ return -1; + } + #endif + +--- svgalib-1.9.21/demos/Makefile.demos 2004-11-16 08:59:52.000000000 +0100 ++++ svgalib-1.9.21/demos/Makefile 2005-07-01 20:59:09.000000000 +0200 +@@ -4,19 +4,15 @@ + # This file is a part of SVGAlib. + #---------------------------------------------------------------------- + +-include ../Makefile.cfg +- +-srcdir = .. +-VPATH = $(srcdir)/demos +- + #---------------------------------------------------------------------- +-# Compiler Section (overrides Makefile.cfg) ++# Compiler Section + #---------------------------------------------------------------------- + +-CFLAGS = $(WARN) $(OPTIMIZE) -I$(srcdir)/include -I$(srcdir)/gl $(DEBFLAGS) +-ifeq (a.out, $(TARGET_FORMAT)) +- CFLAGS += -DSVGA_AOUT +-endif ++CC = gcc ++CFLAGS = -Wall -Wstrict-prototypes ++CFLAGS += -fomit-frame-pointer -O2 -fno-strength-reduce -pipe -g ++LDFLAGS = -s ++LIBS = -lvgagl -lvga -lm + + #---------------------------------------------------------------------- + # Rules Section +@@ -25,51 +21,12 @@ + PROGS = fun testgl speedtest mousetest vgatest scrolltest testlinear \ + keytest testaccel accel forktest eventtest spin bg_test printftest \ + joytest mjoytest bankspeed lineart linearspeed addmodetest \ +- svidtune linearfork cursor vgatweak buildcsr +- +-# Determine what library (static or shared) we will be linking programs with +-ifdef INSTALLSHAREDLIB +- LIBS = -lvgagl -lvga +-endif +-ifndef LIBS +- LIBS = ../staticlib/libvgagl.a ../staticlib/libvga.a -lm +- LVGADEP = $(LIBS) +-endif ++ svidtune linearfork cursor vgatweak + + all: $(PROGS) + +-.PHONY: all clean cleanbin dep +- +-$(PROGS): $(LVGADEP) +- + .c: + $(CC) $(CFLAGS) $(LDFLAGS) -o $* $*.c $(LIBS) + +-rwpage: rwpage.pp +- $(PC) -Rintel rwpage.pp +- +-testaccel: testaccel.c +- $(CC) $(CFLAGS) $(LDFLAGS) -o testaccel testaccel.c $(LIBS) -lm +- +-accel: accel.c +- $(CC) $(CFLAGS) $(LDFLAGS) -o accel accel.c $(LIBS) -lm +- +-linearspeed: linearspeed.c memset.o +- $(CC) $(CFLAGS) $(LDFLAGS) -o linearspeed linearspeed.c memset.o $(LIBS) +- +-buildcsr: mkcur.o +- $(CC) -o buildcsr $(LDFLAGS) mkcur.o -lvgagl -lvga +- +-clean: cleanbin +- rm -f .depend *.o *~ *.bak core +- +-cleanbin: +- rm -f $(PROGS) rwpage +- +-# +-# No dependencies required here. +-# +- +-dep: +-.depend: +- ++clean: ++ rm -f $(PROGS) +--- svgalib-1.9.21/demos/mousetest.c.demos 2000-01-06 13:12:36.000000000 +0100 ++++ svgalib-1.9.21/demos/mousetest.c 2005-07-01 20:51:55.000000000 +0200 +@@ -34,7 +34,7 @@ + + if (!vga_hasmode(vgamode)) { + printf("Mode not available.\n"); +- exit(-1); ++ return -1; + } + #ifndef MANUALLY_SETUP_MOUSE + /* Enable automatic mouse setup at mode set. */ +@@ -72,7 +72,7 @@ + /* To be able to test fake mouse events... */ + if (keyboard_init()) { + printf("Could not initialize keyboard.\n"); +- exit(1); ++ return 1; + } + + /* Set the range for the wheel */ +@@ -136,5 +136,5 @@ + #endif + + vga_setmode(TEXT); +- exit(0); ++ return 0; + } diff --git a/source/l/svgalib/svgalib-1.9.25.no_asm.patch b/source/l/svgalib/svgalib-1.9.25.no_asm.patch new file mode 100644 index 000000000..8e489774b --- /dev/null +++ b/source/l/svgalib/svgalib-1.9.25.no_asm.patch @@ -0,0 +1,11 @@ +--- ./Makefile.cfg.orig 2022-01-19 16:04:36.833030933 -0600 ++++ ./Makefile.cfg 2022-01-19 16:05:13.758031759 -0600 +@@ -79,7 +79,7 @@ + + # uncomment this if your compiler fails on compiling the assembler in + # src/vgaconvplanar.c, gl/inlstring.h, gl/line.c or gl/scale.c +-# NO_ASM = y ++NO_ASM = y + + # uncomment if you want to set attribute controller and dac without delay + # This breaks original VGA, but seems to work on new cards. diff --git a/source/l/svgalib/svgalib.SlackBuild b/source/l/svgalib/svgalib.SlackBuild index 76e9868a4..880c7c6bd 100755 --- a/source/l/svgalib/svgalib.SlackBuild +++ b/source/l/svgalib/svgalib.SlackBuild @@ -1,6 +1,6 @@ #!/bin/bash -# Copyright 2006, 2007, 2008, 2009, 2010, 2015, 2018 Patrick J. Volkerding, Sebeka, MN, USA +# Copyright 2006, 2007, 2008, 2009, 2010, 2015, 2018, 2021 Patrick J. Volkerding, Sebeka, MN, USA # All rights reserved. # # Redistribution and use of this script, with or without modification, is @@ -23,8 +23,8 @@ cd $(dirname $0) ; CWD=$(pwd) PKGNAM=svgalib -VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z* | rev | cut -f 3- -d . | cut -f 1 -d - | rev)} -BUILD=${BUILD:-6} +VERSION=${VERSION:-$(echo $PKGNAM-*.tar.?z | rev | cut -f 3- -d . | cut -f 1 -d - | rev)} +BUILD=${BUILD:-7} # Automatically determine the architecture we're building on: if [ -z "$ARCH" ]; then @@ -65,7 +65,7 @@ mkdir -p $TMP $PKG cd $TMP rm -rf ${PKGNAM}-${VERSION} -tar xvf $CWD/${PKGNAM}-$VERSION.tar.?z* || exit 1 +tar xvf $CWD/${PKGNAM}-$VERSION.tar.?z || exit 1 cd ${PKGNAM}-$VERSION || exit 1 # Make sure ownerships and permissions are sane: @@ -89,6 +89,8 @@ zcat $CWD/svgalib.nohelper.diff.gz | patch -p1 --verbose || exit 1 zcat $CWD/svgalib-1.9.25-round_gtf_gtfcalc_c.patch.gz | patch -p1 --verbose || exit 1 zcat $CWD/svgalib-1.9.25-vga_getmodenumber.patch.gz | patch -p1 --verbose || exit 1 zcat $CWD/svgalib-1.9.25-quickmath-h-redefinitions.patch.gz | patch -p1 --verbose || exit 1 +zcat $CWD/svgalib-1.9.21-demos.patch.gz | patch -p1 --verbose || exit 1 +zcat $CWD/svgalib-1.9.25.no_asm.patch.gz | patch -p1 --verbose || exit 1 # Build and install - spamming your partition first...: make install NO_HELPER=y || exit 1 |