Initial upload of HyprArch releng configuration

airootfs/usr/include/libcalamares/widgets/ClickableLabel.h

@@ -0,0 +1,51 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
+ *   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef LIBCALAMARESUI_WIDGETS_CLICKABLELABEL_H
+#define LIBCALAMARESUI_WIDGETS_CLICKABLELABEL_H
+
+#include <QElapsedTimer>
+#include <QLabel>
+
+#include "DllMacro.h"
+
+namespace Calamares
+{
+namespace Widgets
+{
+/** @brief A Label where the whole label area is clickable
+ *
+ * When clicking anywhere on the Label (text, background, whatever)
+ * the signal clicked() is emitted. Use this as a buddy for radio
+ * buttons or other clickable things where you want mouse interaction
+ * with the label, to be the same as mouse interaction with the control.
+ */
+class UIDLLEXPORT ClickableLabel : public QLabel
+{
+    Q_OBJECT
+public:
+    explicit ClickableLabel( QWidget* parent = nullptr );
+    explicit ClickableLabel( const QString& text, QWidget* parent = nullptr );
+    ~ClickableLabel() override;
+
+signals:
+    void clicked();
+
+protected:
+    virtual void mousePressEvent( QMouseEvent* event ) override;
+    virtual void mouseReleaseEvent( QMouseEvent* event ) override;
+
+private:
+    QElapsedTimer m_time;
+};
+}  // namespace Widgets
+}  // namespace Calamares
+
+#endif  // LIBCALAMARESUI_WIDGETS_CLICKABLELABEL_H

airootfs/usr/include/libcalamares/widgets/ErrorDialog.h

@@ -0,0 +1,83 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2021 Artem Grinev <agrinev@manjaro.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef LIBCALAMARESUI_ERRORDIALOG_H
+#define LIBCALAMARESUI_ERRORDIALOG_H
+
+#include <QDialog>
+
+namespace Ui
+{
+class ErrorDialog;
+}  // namespace Ui
+
+namespace Calamares
+{
+class ErrorDialog : public QDialog
+{
+    Q_OBJECT
+
+    Q_PROPERTY( QString heading READ heading WRITE setHeading NOTIFY headingChanged )
+    Q_PROPERTY( QString informativeText READ informativeText WRITE setInformativeText NOTIFY informativeTextChanged )
+    Q_PROPERTY( QString details READ details WRITE setDetails NOTIFY detailsChanged )
+    Q_PROPERTY( bool shouldOfferWebPaste READ shouldOfferWebPaste WRITE setShouldOfferWebPaste NOTIFY
+                    shouldOfferWebPasteChanged )
+
+public:
+    explicit ErrorDialog( QWidget* parent = nullptr );
+    ~ErrorDialog() override;
+
+    /** @brief The heading (title) of the error dialog
+     *
+     * This is a short (one-line) title. It is human-readable, so should
+     * be translated at the time it is set.
+     */
+    QString heading() const;
+    void setHeading( const QString& newHeading );
+
+    /** @brief The description of the problem
+     *
+     * Longer, human-readable, description of the problem. This text
+     * is word-wrapped as necessary.
+     */
+    QString informativeText() const;
+    void setInformativeText( const QString& newInformativeText );
+
+    /** @brief Details of the problem
+     *
+     * This is generally command-output; it might not be translated
+     * when set. It should be considered "background to the informative
+     * text", or maybe "the reasons". Write the informative text for
+     * the end-user.
+     */
+    QString details() const;
+    void setDetails( const QString& newDetails );
+
+    /** @brief Enable web-paste button
+     *
+     * The web-paste button can be configured at a global level,
+     * but each individual error dialog can be set separately.
+     */
+    bool shouldOfferWebPaste() const;
+    void setShouldOfferWebPaste( bool newShouldOfferWebPaste );
+
+signals:
+    void headingChanged();
+    void informativeTextChanged();
+    void detailsChanged();
+    void shouldOfferWebPasteChanged();
+
+private:
+    Ui::ErrorDialog* ui;
+    bool m_shouldOfferWebPaste = false;
+};
+
+}  // namespace Calamares
+
+#endif  // LIBCALAMARESUI_ERRORDIALOG_H

airootfs/usr/include/libcalamares/widgets/FixedAspectRatioLabel.h

@@ -0,0 +1,34 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2015 Teo Mrnjavac <teo@kde.org>
+ *   SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef FIXEDASPECTRATIOLABEL_H
+#define FIXEDASPECTRATIOLABEL_H
+
+#include "DllMacro.h"
+
+#include <QLabel>
+#include <QPixmap>
+
+class UIDLLEXPORT FixedAspectRatioLabel : public QLabel
+{
+    Q_OBJECT
+public:
+    explicit FixedAspectRatioLabel( QWidget* parent = nullptr );
+    ~FixedAspectRatioLabel() override;
+
+public slots:
+    void setPixmap( const QPixmap& pixmap );
+    void resizeEvent( QResizeEvent* event ) override;
+
+private:
+    QPixmap m_pixmap;
+};
+
+#endif  // FIXEDASPECTRATIOLABEL_H

airootfs/usr/include/libcalamares/widgets/LogWidget.h

@@ -0,0 +1,55 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2022 Bob van der Linden <bobvanderlinden@gmail.com>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef LIBCALAMARESUI_LOGWIDGET_H
+#define LIBCALAMARESUI_LOGWIDGET_H
+
+#include <QPlainTextEdit>
+#include <QThread>
+#include <QWidget>
+
+namespace Calamares
+{
+
+class LogThread : public QThread
+{
+    Q_OBJECT
+
+    void run() override;
+
+public:
+    explicit LogThread( QObject* parent = nullptr );
+    ~LogThread() override;
+
+Q_SIGNALS:
+    void onLogChunk( const QString& logChunk );
+};
+
+class LogWidget : public QWidget
+{
+    Q_OBJECT
+
+    QPlainTextEdit* m_text;
+    LogThread m_log_thread;
+
+public:
+    explicit LogWidget( QWidget* parent = nullptr );
+
+public Q_SLOTS:
+    /// @brief Called by the thread when there is new data
+    void handleLogChunk( const QString& logChunk );
+
+    /// @brief Stop watching for log data
+    void stop();
+    /// @brief Start watching for new log data
+    void start();
+};
+
+}  // namespace Calamares
+#endif  // LOGWIDGET_H

airootfs/usr/include/libcalamares/widgets/PrettyRadioButton.h

@@ -0,0 +1,79 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef LIBCALAMARESUI_WIDGETS_PRETTYRADIOBUTTON_H
+#define LIBCALAMARESUI_WIDGETS_PRETTYRADIOBUTTON_H
+
+#include "DllMacro.h"
+
+#include <QRadioButton>
+
+class QButtonGroup;
+class QComboBox;
+class QGridLayout;
+class QHBoxLayout;
+
+namespace Calamares
+{
+namespace Widgets
+{
+class ClickableLabel;
+
+/** @brief A radio button with fancy label next to it.
+ *
+ * The fancy label is used so that the text alongside the radio
+ * button can word-wrap, be multi-line, and support rich text.
+ *
+ * The radio button itself can be retrieved with buttonWidget(),
+ * and the whole behaves a lot like a label. Extra options can be
+ * added to the display (options are hidden when the button is
+ * not selected) with addOptionsComboBox().
+ */
+class UIDLLEXPORT PrettyRadioButton : public QWidget
+{
+    Q_OBJECT
+public:
+    explicit PrettyRadioButton( QWidget* parent = nullptr );
+    ~PrettyRadioButton() override {}
+
+    /// @brief Passes @p text on to the ClickableLabel
+    void setText( const QString& text );
+
+    // Icon applies to the radio-button part
+    void setIconSize( const QSize& size );
+    QSize iconSize() const;
+    void setIcon( const QIcon& icon );
+
+    // Applies to the radio-button part
+    void setChecked( bool checked );
+    bool isChecked() const;
+
+    /** @brief Adds the radio-button part to the given @p group
+     *
+     * For managing the pretty-radio-button in button groups like normal
+     * radio buttons, call addToGroup() rather that group->addButton().
+     */
+    void addToGroup( QButtonGroup* group, int id = -1 );
+
+    /// @brief Add an options drop-down to this button.
+    void addOptionsComboBox( QComboBox* );
+
+protected slots:
+    /// Options are hidden when the radio button is off
+    void toggleOptions( bool checked );
+
+protected:
+    ClickableLabel* m_label;
+    QRadioButton* m_radio;
+    QGridLayout* m_mainLayout;
+    QHBoxLayout* m_optionsLayout;
+};
+}  // namespace Widgets
+}  // namespace Calamares
+#endif  // LIBCALAMARESUI_WIDGETS_PRETTYRADIOBUTTON_H

airootfs/usr/include/libcalamares/widgets/TranslationFix.h

@@ -0,0 +1,34 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2021 Adriaan de Groot <groot@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef LIBCALAMARESUI_WIDGETS_TRANSLATIONFIX_H
+#define LIBCALAMARESUI_WIDGETS_TRANSLATIONFIX_H
+
+#include "DllMacro.h"
+
+class QMessageBox;
+class QDialogButtonBox;
+
+namespace Calamares
+{
+
+/** @brief Fixes the labels on the standard buttons of the message box
+ *
+ * Updates OK / Cancel / Yes / No because there does not
+ * seem to be a way to do so in the Retranslator code
+ * (in libcalamares) since the translated strings may come
+ * from a variety of platform-plugin sources and we can't
+ * guess the context.
+ */
+void UIDLLEXPORT fixButtonLabels( QMessageBox* );
+
+void UIDLLEXPORT fixButtonLabels( QDialogButtonBox* );
+}  // namespace Calamares
+
+#endif

airootfs/usr/include/libcalamares/widgets/WaitingWidget.h

@@ -0,0 +1,78 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2014 Teo Mrnjavac <teo@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef WAITINGWIDGET_H
+#define WAITINGWIDGET_H
+
+#include "DllMacro.h"
+
+#include "widgets/waitingspinnerwidget.h"
+
+#include <chrono>
+#include <memory>
+
+class QLabel;
+class QTimer;
+
+/** @brief A spinner and a label below it
+ *
+ * The spinner has a fixed size of 4* the font height,
+ * and the text is displayed centered below it. Use this
+ * to display a long-term waiting situation with a status report.
+ */
+class UIDLLEXPORT WaitingWidget : public WaitingSpinnerWidget
+{
+public:
+    /// Create a WaitingWidget with initial @p text label.
+    explicit WaitingWidget( const QString& text, QWidget* parent = nullptr );
+    ~WaitingWidget() override;
+
+protected:
+    void changeEvent( QEvent* event ) override;
+};
+
+/** @brief A spinner and a countdown inside it
+ *
+ * The spinner is sized to the text-height and displays a
+ * numeric countdown iside the spinner. The countdown is updated
+ * every second. The signal timeout() is sent every time
+ * the countdown reaches 0.
+ */
+class UIDLLEXPORT CountdownWaitingWidget : public WaitingSpinnerWidget
+{
+    Q_OBJECT
+public:
+    /// Create a countdown widget with a given @p duration
+    explicit CountdownWaitingWidget( std::chrono::seconds duration = std::chrono::seconds( 5 ),
+                                     QWidget* parent = nullptr );
+    ~CountdownWaitingWidget() override;
+
+    /// Changes the duration used and resets the countdown
+    void setInterval( std::chrono::seconds duration );
+
+    /// Start the countdown, resets to the full duration
+    void start();
+    /// Stop the countdown
+    void stop();
+
+Q_SIGNALS:
+    void timeout();
+
+protected Q_SLOTS:
+    void tick();
+
+protected:
+    void changeEvent( QEvent* event ) override;
+
+private:
+    struct Private;
+    std::unique_ptr< Private > d;
+};
+
+#endif  // WAITINGWIDGET_H

airootfs/usr/include/libcalamares/widgets/waitingspinnerwidget.h

@@ -0,0 +1,162 @@
+/*
+ *   SPDX-FileCopyrightText: 2012-2014 Alexander Turkin
+ *   SPDX-FileCopyrightText: 2014 William Hallatt
+ *   SPDX-FileCopyrightText: 2015 Jacob Dawid
+ *   SPDX-FileCopyrightText: 2018 huxingyi
+ *   SPDX-License-Identifier: MIT
+ */
+
+/* Original Work Copyright (c) 2012-2014 Alexander Turkin
+   Modified 2014 by William Hallatt
+   Modified 2015 by Jacob Dawid
+
+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 AUTHORS OR
+COPYRIGHT HOLDERS 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.
+*/
+
+#pragma once
+
+#include "DllMacro.h"
+
+#include <QColor>
+#include <QTimer>
+#include <QWidget>
+
+class UIDLLEXPORT WaitingSpinnerWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    /** @brief Constructor for "standard" widget behaviour
+     *
+     * Use this constructor if you wish to, e.g. embed your widget in another.
+     */
+    WaitingSpinnerWidget( QWidget* parent = nullptr,
+                          bool centerOnParent = true,
+                          bool disableParentWhenSpinning = true );
+
+    /** @brief Constructor
+     *
+     * Use this constructor to automatically create a modal
+     * ("blocking") spinner on top of the calling widget/window.  If a valid
+     * parent widget is provided, "centreOnParent" will ensure that
+     * QtWaitingSpinner automatically centres itself on it, if not,
+     * @p centerOnParent is ignored.
+     */
+    WaitingSpinnerWidget( Qt::WindowModality modality,
+                          QWidget* parent = nullptr,
+                          bool centerOnParent = true,
+                          bool disableParentWhenSpinning = true );
+
+    WaitingSpinnerWidget( const WaitingSpinnerWidget& ) = delete;
+    WaitingSpinnerWidget& operator=( const WaitingSpinnerWidget& ) = delete;
+
+    void setColor( QColor color );
+    void setTextColor( QColor color );
+    void setRoundness( qreal roundness );
+    void setMinimumTrailOpacity( qreal minimumTrailOpacity );
+    void setTrailFadePercentage( qreal trail );
+    void setRevolutionsPerSecond( qreal revolutionsPerSecond );
+    void setNumberOfLines( int lines );
+    void setLineLength( int length );
+    void setLineWidth( int width );
+    void setInnerRadius( int radius );
+
+    /** @brief Sets the text displayed in or below the spinner
+     *
+     * If the text is empty, no text is displayed. The text is displayed
+     * in or below the spinner depending on the value of alignment().
+     * With AlignBottom, the text is displayed below the spinner,
+     * centered horizontally relative to the spinner; any other alignment
+     * will put the text in the middle of the spinner itself.
+     *
+     * TODO: this does not support rich text. Rich text could be done
+     *       through a QStaticText, or an HTML document. However, then
+     *       we need to do more alignment calculations ourselves.
+     */
+    void setText( const QString& text );
+    /** @brief Sets the alignment of text for the spinner
+     *
+     * The only meaningful values are AlignBottom and AlignVCenter,
+     * for text below the spinner and text in the middle.
+     */
+    void setAlignment( Qt::AlignmentFlag align );
+    /// Convenience to set text-in-the-middle (@c true) or text-at-bottom (@c false)
+    void setCenteredText( bool centered )
+    {
+        setAlignment( centered ? Qt::AlignmentFlag::AlignVCenter : Qt::AlignmentFlag::AlignBottom );
+    }
+
+    QColor color() const;
+    QColor textColor() const;
+    QString text() const;
+    Qt::AlignmentFlag alignment() const { return _alignment; }
+    qreal roundness() const;
+    qreal minimumTrailOpacity() const;
+    qreal trailFadePercentage() const;
+    qreal revolutionsPersSecond() const;
+    int numberOfLines() const;
+    int lineLength() const;
+    int lineWidth() const;
+    int innerRadius() const;
+
+    bool isSpinning() const;
+
+public Q_SLOTS:
+    void start();
+    void stop();
+
+private Q_SLOTS:
+    void rotate();
+
+protected:
+    void paintEvent( QPaintEvent* paintEvent ) override;
+
+private:
+    void updateSize();
+    void updateTimer();
+    void updatePosition();
+
+private:
+    // PI, leading to a full fade in one whole revolution
+    static constexpr const auto radian = 3.14159265358979323846;
+
+    // Spinner-wheel related settings
+    QColor _color = Qt::black;
+    qreal _roundness = 100.0;  // 0..100
+    qreal _minimumTrailOpacity = radian;
+    qreal _trailFadePercentage = 80.0;
+    qreal _revolutionsPerSecond = radian / 2;
+    int _numberOfLines = 20;
+    int _lineLength = 10;
+    int _lineWidth = 2;
+    int _innerRadius = 10;
+    QSize _imageSize;
+
+    // Text-related settings
+    Qt::AlignmentFlag _alignment = Qt::AlignmentFlag::AlignBottom;
+    QString _text;
+    QColor _textColor = Qt::black;
+
+    // Environment settings
+    bool _centerOnParent = true;
+    bool _disableParentWhenSpinning = true;
+
+    // Internal bits
+    QTimer* _timer = nullptr;
+    int _currentCounter = 0;
+    bool _isSpinning = false;
+};