#include <KisApplicationArguments.h>

Inheritance diagram for KisApplicationArguments:

Public Member Functions
bool	canvasOnly () const

KisDocument *	createDocumentFromArguments () const

bool	doNewImage () const

bool	doTemplate () const

bool	exportAs () const

QString	exportFileName () const

bool	exportSequence () const

QString	fileLayer () const

QStringList	filenames () const

bool	fullScreen () const

	KisApplicationArguments (const KisApplicationArguments &rhs)

	KisApplicationArguments (const QApplication &app)

bool	noSplash () const

void	operator= (const KisApplicationArguments &rhs)

	Private ()

QByteArray	serialize ()

QString	session () const

QString	windowLayout () const

QString	workspace () const

	~KisApplicationArguments ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Static Public Member Functions
static KisApplicationArguments	deserialize (QByteArray &serialized)

Public Attributes
bool	canvasOnly {false}

QString	colorDepth {"U8"}

QString	colorModel {"RGBA"}

bool	doTemplate {false}

int	dpiX {72}

int	dpiY {72}

bool	exportAs {false}

QString	exportFileName

bool	exportSequence {false}

QString	fileLayer

QStringList	filenames

bool	fullScreen {false}

int	height {5000}

bool	newImage {false}

bool	noSplash {false}

QString	session

int	width {2000}

QString	windowLayout

QString	workspace

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Private Member Functions
	KisApplicationArguments ()

Private Attributes
const QScopedPointer< Private >	d

Detailed Description

Definition at line 23 of file KisApplicationArguments.cpp.

Constructor & Destructor Documentation

◆ KisApplicationArguments() [1/3]

KisApplicationArguments::KisApplicationArguments ( const QApplication & app )

Definition at line 63 of file KisApplicationArguments.cpp.

    : d(new Private)
{
    QCommandLineParser parser;
    parser.addVersionOption();
    parser.addHelpOption();
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("template"), i18n("Open a new document with a template")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("new-image"), i18n("Create a new image.\n"
                                                                                          "Possible colorspace values are:\n"
                                                                                          "    * RGBA\n"
                                                                                          "    * XYZA\n"
                                                                                          "    * LABA\n"
                                                                                          "    * CMYKA\n"
                                                                                          "    * GRAY\n"
                                                                                          "    * YCbCrA\n"
                                                                                          "Possible channel depth arguments are\n"
                                                                                          "    * U8 (8 bits integer)\n"
                                                                                          "    * U16 (16 bits integer)\n"
                                                                                          "    * F16 (16 bits floating point)\n"
                                                                                          "    * F32 (32 bits floating point)\n"),
                                        QLatin1String("colorspace,depth,width,height")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("workspace"), i18n("The name of the workspace to open Krita with"), QLatin1String("workspace")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("windowlayout"), i18n("The name of the window layout to open Krita with"), QLatin1String("windowlayout")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("load-session"), i18n("The name of the session to open Krita with"), QLatin1String("load-session"))); // NB: the argument "session" is already used by QGuiApplication
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("canvasonly"), i18n("Start Krita in canvas-only mode")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("nosplash"), i18n("Do not show the splash screen")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("fullscreen"), i18n("Start Krita in full-screen mode")));
    {
        QCommandLineOption opt(QStringList() << QLatin1String("dpi"), i18n("Override display DPI"), QLatin1String("dpiX,dpiY"));
        opt.setFlags(QCommandLineOption::HiddenFromHelp);
        parser.addOption(opt);
    }
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("export"), i18n("Export to the given filename and exit")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("export-sequence"), i18n("Export animation to the given filename and exit")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("export-filename"), i18n("Filename for export"), QLatin1String("filename")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("file-layer"), i18n("File layer to be added to existing or new file"), QLatin1String("file-layer")));
    parser.addOption(QCommandLineOption(QStringList() << QLatin1String("resource-location"), i18n("A location that overrides the configured location for Krita's resources"), QLatin1String("file-layer")));
    parser.addPositionalArgument(QLatin1String("[file(s)]"), i18n("File(s) or URL(s) to open"));
 
    QStringList filteredArgs;
    {
        auto checkIsIgnoreEpic = [](const QString &arg) {
            // List according to https://dev.epicgames.com/docs/services/en-US/Interfaces/Auth/index.html#epicgameslauncher
            static const QStringList epicIgnoreArgsStart = {
                QStringLiteral("AUTH_PASSWORD="),
                QStringLiteral("AUTH_LOGIN="),
                QStringLiteral("AUTH_TYPE="),
                QStringLiteral("epicapp="),
                QStringLiteral("epicenv="),
                QStringLiteral("epicusername="),
                QStringLiteral("epicuserid="),
                QStringLiteral("epiclocale="),
                QStringLiteral("epicsandboxid="),
            };
            static const QStringList epicIgnoreArgsExact = {
                QStringLiteral("EpicPortal"),
            };
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
            QStringRef argDashless(&arg);
#else
            QStringView argDashless(arg);
#endif
            // Strip leading dashes.
            while (argDashless.startsWith('-')) {
                argDashless = argDashless.mid(1);
            }
            Q_FOREACH(const auto &argToIgnore, epicIgnoreArgsStart) {
                if (argDashless.startsWith(argToIgnore, Qt::CaseInsensitive)) {
                    return true;
                }
            }
            Q_FOREACH(const auto &argToIgnore, epicIgnoreArgsExact) {
                if (argDashless.compare(argToIgnore, Qt::CaseInsensitive) == 0) {
                    return true;
                }
            }
            return false;
        };
 
        QStringListIterator iter(app.arguments());
        if (iter.hasNext()) {
            // First argument is application name.
            filteredArgs.append(iter.next());
 
            bool isAfterDoubleDash = false;
            while (iter.hasNext()) {
                QString arg = iter.next();
                if (arg == QLatin1String("--")) {
                    isAfterDoubleDash = true;
                }
                if (isAfterDoubleDash || !checkIsIgnoreEpic(arg)) {
                    filteredArgs.append(arg);
                }
            }
        }
    }
 
    parser.process(filteredArgs);
 
    QString dpiValues = parser.value("dpi");
    if (!dpiValues.isEmpty()) {
        qWarning() << "The `dpi` argument does nothing!";
    }
 
    QString newImageValues = parser.value("new-image");
    d->newImage = !newImageValues.isEmpty();
    if (d->newImage) {
        QStringList v = newImageValues.split(",");
        if (v.size() != 4) {
            d->newImage = false;
            qWarning() << "Cannot create a new image: please specify colormodel, depth, width and height.";
        }
        d->colorModel = v[0].toUpper();
        d->colorDepth = v[1].toUpper();
        d->width = v[2].toInt();
        d->height = v[3].toInt();
    }
 
    d->fileLayer = parser.value("file-layer");
    d->exportFileName = parser.value("export-filename");
    d->workspace = parser.value("workspace");
    d->windowLayout = parser.value("windowlayout");
    d->session = parser.value("load-session");
    d->doTemplate = parser.isSet("template");
    d->exportAs = parser.isSet("export");
    d->exportSequence = parser.isSet("export-sequence");
    d->canvasOnly = parser.isSet("canvasonly");
    d->noSplash = parser.isSet("nosplash");
    d->fullScreen = parser.isSet("fullscreen");
 
    KoResourcePaths::s_overrideAppDataLocation = parser.value("resource-location");
 
    const QDir currentDir = QDir::current();
    Q_FOREACH (const QString &filename, parser.positionalArguments()) {
        d->filenames << currentDir.absoluteFilePath(filename);
    }
}

References d, KoResourcePaths::s_overrideAppDataLocation, and v.

◆ KisApplicationArguments() [2/3]

KisApplicationArguments::KisApplicationArguments ( const KisApplicationArguments & rhs )

Definition at line 201 of file KisApplicationArguments.cpp.

    : d(new Private)
{
    d->filenames = rhs.filenames();
    d->dpiX = rhs.d->dpiX;
    d->dpiY = rhs.d->dpiY;
    d->doTemplate = rhs.doTemplate();
    d->exportAs = rhs.exportAs();
    d->exportFileName = rhs.exportFileName();
    d->canvasOnly = rhs.canvasOnly();
    d->workspace = rhs.workspace();
    d->windowLayout = rhs.windowLayout();
    d->session = rhs.session();
    d->noSplash = rhs.noSplash();
    d->fullScreen = rhs.fullScreen();
 
}

References canvasOnly, d, doTemplate, exportAs, exportFileName, filenames, fullScreen, noSplash, session, windowLayout, and workspace.

◆ ~KisApplicationArguments()

KisApplicationArguments::~KisApplicationArguments ( )

Definition at line 59 of file KisApplicationArguments.cpp.

60{

61}

◆ KisApplicationArguments() [3/3]

KisApplicationArguments::KisApplicationArguments ( )

private

Definition at line 53 of file KisApplicationArguments.cpp.

    : d(new Private)
{
}

Member Function Documentation

◆ canvasOnly()

bool KisApplicationArguments::canvasOnly ( ) const

◆ createDocumentFromArguments()

KisDocument * KisApplicationArguments::createDocumentFromArguments ( ) const

Definition at line 375 of file KisApplicationArguments.cpp.

{
    KisDocument *doc = KisPart::instance()->createDocument();
    const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(d->colorModel, d->colorDepth, "");
    if (!cs) {
        qWarning() << "Could not create the colorspace for the new image. Check the colorspace and depth arguments.";
        return 0;
    }
 
    doc->newImage(i18n("Unnamed"), d->width, d->height, cs, KoColor(QColor(Qt::white), cs), KisConfig::CANVAS_COLOR, 1, "", 100.0);
    return doc;
}

References KisConfig::CANVAS_COLOR, KoColorSpaceRegistry::colorSpace(), KisPart::createDocument(), d, KoColorSpaceRegistry::instance(), KisPart::instance(), and KisDocument::newImage().

◆ deserialize()

KisApplicationArguments KisApplicationArguments::deserialize ( QByteArray & serialized )

static

Definition at line 271 of file KisApplicationArguments.cpp.

{
    KisApplicationArguments args;
 
    QBuffer buf(&serialized);
    buf.open(QIODevice::ReadOnly);
    QDataStream ds(&buf);
    ds.setVersion(QDataStream::Qt_5_0);
    qsizetype fileNamesCount;
    ds >> fileNamesCount;
    for(int i = 0; i < fileNamesCount; ++i) {
        QString s;
        ds >> s;
        args.d->filenames << s;
    }
    ds >> args.d->dpiX;
    ds >> args.d->dpiY;
    ds >> args.d->doTemplate;
    ds >> args.d->exportAs;
    ds >> args.d->exportFileName;
    ds >> args.d->workspace;
    ds >> args.d->windowLayout;
    ds >> args.d->session;
    ds >> args.d->canvasOnly;
    ds >> args.d->noSplash;
    ds >> args.d->fullScreen;
    ds >> args.d->newImage;
    ds >> args.d->height;
    ds >> args.d->width;
    ds >> args.d->height;
    ds >> args.d->colorModel;
    ds >> args.d->colorDepth;
    ds >> args.d->fileLayer;
 
    buf.close();
 
    return args;
}

References d.

◆ doNewImage()

bool KisApplicationArguments::doNewImage ( ) const

Definition at line 370 of file KisApplicationArguments.cpp.

{
    return d->newImage;
}

References d.

◆ doTemplate()

bool KisApplicationArguments::doTemplate ( ) const

◆ exportAs()

bool KisApplicationArguments::exportAs ( ) const

◆ exportFileName()

QString KisApplicationArguments::exportFileName ( ) const

◆ exportSequence()

bool KisApplicationArguments::exportSequence ( ) const

◆ fileLayer()

QString KisApplicationArguments::fileLayer ( ) const

◆ filenames()

QStringList KisApplicationArguments::filenames ( ) const

◆ fullScreen()

bool KisApplicationArguments::fullScreen ( ) const

◆ noSplash()

bool KisApplicationArguments::noSplash ( ) const

◆ operator=()

void KisApplicationArguments::operator= ( const KisApplicationArguments & rhs )

Definition at line 219 of file KisApplicationArguments.cpp.

{
    d->filenames = rhs.filenames();
    d->dpiX = rhs.d->dpiX;
    d->dpiY = rhs.d->dpiY;
    d->doTemplate = rhs.doTemplate();
    d->exportAs = rhs.exportAs();
    d->exportFileName = rhs.exportFileName();
    d->canvasOnly = rhs.canvasOnly();
    d->workspace = rhs.workspace();
    d->windowLayout = rhs.windowLayout();
    d->session = rhs.session();
    d->noSplash = rhs.noSplash();
    d->fullScreen = rhs.fullScreen();
}

References canvasOnly, d, doTemplate, exportAs, exportFileName, filenames, fullScreen, noSplash, session, windowLayout, and workspace.

◆ Private()

KisApplicationArguments::Private ( )

inline

Definition at line 25 of file KisApplicationArguments.cpp.

26 {

27 }

◆ serialize()

QByteArray KisApplicationArguments::serialize ( )

Definition at line 235 of file KisApplicationArguments.cpp.

{
    QBuffer buf;
    buf.open(QIODevice::WriteOnly);
    QDataStream ds(&buf);
    ds.setVersion(QDataStream::Qt_5_0);
    // explicitly declare the type of the size variable
    const qsizetype fileNamesCount = d->filenames.count();
    ds << fileNamesCount;
    Q_FOREACH (const QString &filename, d->filenames) {
        ds << filename;
    }
    ds << d->dpiX;
    ds << d->dpiY;
    ds << d->doTemplate;
    ds << d->exportAs;
    ds << d->exportFileName;
    ds << d->workspace;
    ds << d->windowLayout;
    ds << d->session;
    ds << d->canvasOnly;
    ds << d->noSplash;
    ds << d->fullScreen;
    ds << d->newImage;
    ds << d->height;
    ds << d->width;
    ds << d->height;
    ds << d->colorModel;
    ds << d->colorDepth;
    ds << d->fileLayer;
 
    buf.close();
 
    return buf.data();
}