plasma-show-stdout.hpp

Go to the documentation of this file.

/*
 * Copyright (c) <2026> Anthony J. Greenberg
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */


 
#pragma once
 
#include <QObject>
#include <QString>
#include <QVariantList>
#include <QQmlExtensionPlugin>
 
#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <deque>
#include <filesystem>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
namespace PSSspace {
    struct ModuleSpec {
        enum class Kind { Timed, Signal };
        Kind                            kind;
        std::filesystem::path           script;
        std::chrono::duration<uint32_t> interval{};
        int                             signalNumber{0};
        size_t                          outputLimit{300};
    };

    class ScriptOutput : public QObject {
        // macros that define private declarations
        Q_OBJECT
        Q_PROPERTY(QString text READ text NOTIFY textChanged)
        Q_PROPERTY(QString delimiter READ delimiter WRITE setDelimiter NOTIFY delimiterChanged)
        Q_PROPERTY(int maxSignalOffset READ maxSignalOffset CONSTANT)
        Q_PROPERTY(qint64 hostPid READ hostPid CONSTANT)
        Q_PROPERTY(QString hostName READ hostName CONSTANT)
    public:
        explicit ScriptOutput(QObject *parent = nullptr);
        explicit ScriptOutput(std::vector<ModuleSpec> specs, QObject *parent = nullptr);
        ~ScriptOutput() override;
        QString text() const { return text_; }
        QString delimiter() const { return delimiter_; }
        void setDelimiter(const QString &delimiter);
        int maxSignalOffset() const;
        qint64 hostPid() const;
        QString hostName() const;
        Q_INVOKABLE void setModules(const QVariantList &specs);
    signals:
        void textChanged();
        void delimiterChanged();
    private:
        struct ModuleSlot {
            std::condition_variable *changeSignal{nullptr};
            std::string *outputBuffer{nullptr};
            QString fragment;
            std::thread worker;
            std::thread bridge;
            std::shared_ptr<bool> execute;
            std::condition_variable *executionSignal{nullptr};
            int signalNumber{0};
        };

        void startModules_(std::vector<ModuleSpec> specs);
        void stopModules_();
        void bridgeLoop_(ModuleSlot *slot);
        void signalWaitLoop_();
        void rebuildCombinedText_();

        QString text_;
        QString delimiter_{ QStringLiteral(" | ") };

        std::shared_ptr<std::mutex> mutex_;
        std::shared_ptr<std::condition_variable> stopSignal_;
        std::shared_ptr<bool> stop_;

        std::deque<ModuleSlot> slots_;
        std::thread signalWaitThread_;
        bool signalsActive_{false};
    };
 
} // namespace PSSspace

class ShowStdoutPlugin final : public QQmlExtensionPlugin {
    // macros that define private declarations
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
public:
    void registerTypes(const char *uri) override;
};