File indexing completed on 2025-01-12 03:40:55

 /* SPDX-FileCopyrightText: 2023 Noah Davis <noahadvs@gmail.com>
  * SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include <KAboutData>
 #include <KCompressionDevice>
 #include <KSvg/Svg>
 #include <QCommandLineOption>
 #include <QCommandLineParser>
 #include <QCoreApplication>
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QRegularExpression>
 #include <QSvgRenderer>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
 using namespace Qt::Literals::StringLiterals; // for ""_L1
 
 static KSvg::Svg s_ksvg;
 static QSvgRenderer s_renderer;
 
 // https://developer.mozilla.org/en-US/docs/Web/SVG/Element#renderable_elements
 static const QStringList s_renderableElements = {
     "a"_L1, "circle"_L1, "ellipse"_L1, "foreignObject"_L1, "g"_L1, "image"_L1,
     "line"_L1, "path"_L1, "polygon"_L1, "polyline"_L1, "rect"_L1, // excluding <svg>
     "switch"_L1, "symbol"_L1, "text"_L1, "textPath"_L1, "tspan"_L1, "use"_L1
 };
 
 QString joinedStrings(const QStringList &strings)
 {
     return strings.join("\", \""_L1).prepend("\""_L1).append("\""_L1);
 }
 
 // Translate the current element to (0,0) if possible.
 // FIXME: Does not necessarily translate to (0,0) in one go.
 void writeElementTranslation(QXmlStreamReader &reader, QXmlStreamWriter &writer, qreal dx, qreal dy)
 {
     if ((qIsFinite(dx) && dx != 0) || (qIsFinite(dy) && dy != 0)) {
         writer.writeStartElement(reader.qualifiedName()); // The thing reader has currently read.
         auto attributes = reader.attributes();
         bool wasTranslated = false;
         QString svgTranslate = "translate(%1,%2)"_L1.arg(QString::number(dx), QString::number(dy));
         for (int i = 0; i < attributes.size(); ++i) {
             if (attributes[i].qualifiedName() == "transform"_L1) {
                 auto svgTransform = attributes[i].value().toString();
                 if (!svgTransform.isEmpty()) {
                     svgTransform += " "_L1;
                 }
                 attributes[i] = {"transform"_L1, svgTransform + svgTranslate};
                 wasTranslated = true;
             }
             writer.writeAttribute(attributes[i]);
         }
         if (!wasTranslated) {
             writer.writeAttribute("transform"_L1, svgTranslate);
         }
     } else {
         writer.writeCurrentToken(reader); // The thing reader has currently read.
     }
 }
 
 QMap<QString, QByteArray> splitSvg(const QString &inputArg, const QByteArray &inputContents)
 {
     s_renderer.load(inputContents);
     QMap<QString, QByteArray> outputMap; // filename, contents
     QXmlStreamReader reader(inputContents);
     reader.setNamespaceProcessing(false);
 
     QString stylesheet;
 
     while (!reader.atEnd() && !reader.hasError()) {
         reader.readNextStartElement();
         if (reader.hasError()) {
             break;
         }
 
         const auto qualifiedName = reader.qualifiedName();
         const auto attributes = reader.attributes();
         QString id = attributes.value("id"_L1).toString();
 
         // Skip elements without IDs since they aren't icons.
         // Make sure you don't miss children when you make the output contents though.
         // Also skip hints and groups with the layer1 ID
         if (id.isEmpty() || id.startsWith("hint-"_L1) || (qualifiedName == "g"_L1 && id == "layer1"_L1)) {
             continue;
         }
 
         // Some SVGs have multiple stylesheets.
         // They really shouldn't, but that's just how it is sometimes.
         // The last stylesheet with the correct ID is the one we will use.
         static const auto s_stylesheetId = "current-color-scheme"_L1;
         if (qualifiedName == "style"_L1 && id == s_stylesheetId) {
             reader.readNext();
             auto text = reader.text();
             if (!text.isEmpty()) {
                 stylesheet = text.toString();
             }
             continue;
         }
 
         // ignore non-renderable elements
         if (!s_renderableElements.contains(qualifiedName)) {
             continue;
         }
 
         // NOTE: Does not include its own transform.
         QTransform transform = s_renderer.transformForElement(id);
         QRectF mappedRect = transform.mapRect(s_renderer.boundsOnElement(id));
 
         // Skip invisible renderable elements.
         if (mappedRect.isEmpty()) {
             continue;
         }
 
         QString outputFilename = id + ".svg"_L1;
         QByteArray outputContents;
         QXmlStreamWriter writer(&outputContents);
         // Start writing document
         writer.setAutoFormatting(true);
         writer.writeStartDocument();
 
         // <svg>
         writer.writeStartElement("svg"_L1);
         writer.writeDefaultNamespace("http://www.w3.org/2000/svg"_L1);
         writer.writeNamespace("http://www.w3.org/1999/xlink"_L1, "xlink"_L1);
         writer.writeNamespace("http://creativecommons.org/ns#"_L1, "cc"_L1);
         writer.writeNamespace("http://purl.org/dc/elements/1.1/"_L1, "dc"_L1);
         writer.writeNamespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#"_L1, "rdf"_L1);
         writer.writeNamespace("http://www.inkscape.org/namespaces/inkscape"_L1, "inkscape"_L1);
         writer.writeNamespace("http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"_L1, "sodipodi"_L1);
         writer.writeAttribute("width"_L1, QString::number(mappedRect.width()));
         writer.writeAttribute("height"_L1, QString::number(mappedRect.height()));
 
         // <style>
         writer.writeStartElement("style"_L1);
         writer.writeAttribute("type"_L1, "text/css"_L1);
         writer.writeAttribute("id"_L1, s_stylesheetId);
         // CSS
         writer.writeCharacters(stylesheet);
         writer.writeEndElement();
         // </style>
 
         // Translation via parent
         auto dx = -mappedRect.x();
         auto dy = -mappedRect.y();
         writeElementTranslation(reader, writer, dx, dy);
 
         // Write contents until we're no longer writing the current element or any of its children.
         int depth = 0;
         while (depth >= 0 && !reader.atEnd() && !reader.hasError()) {
             reader.readNext();
             if (reader.isStartElement()) {
                 ++depth;
             }
             if (reader.isEndElement()) {
                 --depth;
             }
             writer.writeCurrentToken(reader);
         }
 
         if (reader.hasError()) {
             qWarning() << inputArg << "has an error:" << reader.errorString();
             break;
         }
 
         writer.writeEndElement();
         // </svg>
 
         writer.writeEndDocument();
 
         if (!outputFilename.isEmpty() && !outputContents.isEmpty()) {
             outputMap.insert(outputFilename, outputContents);
         }
     }
     return outputMap;
 }
 
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
 
     KAboutData aboutData(app.applicationName(), app.applicationName(), "1.0"_L1,
                          "Splits Plasma/KSVG SVGs into individual SVGs"_L1,
                          KAboutLicense::LGPL_V2, "2023 Noah Davis"_L1);
     aboutData.addAuthor("Noah Davis"_L1, {}, "noahadvs@gmail.com"_L1);
     KAboutData::setApplicationData(aboutData);
 
     QCommandLineParser commandLineParser;
     commandLineParser.addPositionalArgument("inputs"_L1, "Input files (separated by spaces)"_L1, "inputs..."_L1);
     commandLineParser.addPositionalArgument("output"_L1, "Output folder (optional, must exist). The default output folder is the current working directory."_L1, "[output]"_L1);
     aboutData.setupCommandLine(&commandLineParser);
 
     commandLineParser.process(app);
     aboutData.processCommandLine(&commandLineParser);
 
     const QStringList &positionalArguments = commandLineParser.positionalArguments();
     if (positionalArguments.isEmpty()) {
         qWarning() << "The arguments are missing.";
         return 1;
     }
 
     QFileInfo lastArgInfo(positionalArguments.last());
     if (positionalArguments.size() == 1 && lastArgInfo.isDir()) {
         qWarning() << "Input file arguments are missing.";
         return 1;
     }
 
     QDir outputDir = lastArgInfo.isDir() ? lastArgInfo.absoluteFilePath() : QDir::currentPath();
     QFileInfo outputDirInfo(outputDir.absolutePath());
     if (!outputDirInfo.isWritable()) {
         // Using the arg instead of just path or filename so the user sees what they typed.
         auto output = lastArgInfo.isDir() ? positionalArguments.last() : QDir::currentPath();
         qWarning() << output << "is not a writable output folder.";
         return 1;
     }
 
     QStringList inputArgs;
     QStringList ignoredArgs;
     for (int i = 0; i < positionalArguments.size() - lastArgInfo.isDir(); ++i) {
         if (!QFileInfo::exists(positionalArguments[i])) {
             ignoredArgs << positionalArguments[i];
             continue;
         }
         inputArgs << positionalArguments[i];
     }
 
     if (inputArgs.isEmpty()) {
         qWarning() << "None of the input files could be found.";
         return 1;
     }
 
     if (!ignoredArgs.isEmpty()) {
         // Using the arg instead of path or filename so the user sees what they typed.
         qWarning() << "The following input files could not be found:";
         qWarning().noquote() << joinedStrings(ignoredArgs);
     }
 
     bool wasAnyFileWritten = false;
     for (const QString &inputArg : inputArgs) {
         QFileInfo inputInfo(inputArg);
 
         const QString &absoluteInputPath = inputInfo.absoluteFilePath();
         // Avoid reading from a theme with relative paths by accident.
         s_ksvg.setImagePath(absoluteInputPath);
         if (!s_ksvg.isValid()) {
             qWarning() << inputArg << "is not a valid Plasma theme SVG.";
             continue;
         }
 
         KCompressionDevice inputFile(absoluteInputPath, KCompressionDevice::GZip);
         if (!inputFile.open(QIODevice::ReadOnly)) {
             qWarning() << inputArg << "could not be read.";
             continue;
         }
         const auto outputMap = splitSvg(inputArg, inputFile.readAll());
         inputFile.close();
 
         if (outputMap.isEmpty()) {
             qWarning() << inputArg << "could not be split.";
             continue;
         }
 
         const auto outputSubDirPath = outputDir.absoluteFilePath(inputInfo.baseName());
         outputDir.mkpath(outputSubDirPath);
         QDir outputSubDir(outputSubDirPath);
         QStringList unwrittenFiles;
         QStringList invalidSvgs;
         for (auto it = outputMap.cbegin(); it != outputMap.cend(); ++it) {
             const QString &key = it.key();
             const QByteArray &value = it.value();
             if (key.isEmpty() || value.isEmpty()) {
                 unwrittenFiles << key;
                 continue;
             }
             const auto absoluteOutputPath = outputSubDir.absoluteFilePath(key);
             QFile outputFile(absoluteOutputPath);
             if (!outputFile.open(QIODevice::WriteOnly)) {
                 unwrittenFiles << key;
                 continue;
             }
             wasAnyFileWritten |= outputFile.write(value);
             outputFile.close();
             s_renderer.load(absoluteOutputPath);
             if (!s_renderer.isValid()) {
                 // Write it even if it isn't valid so that the user can examine the output.
                 invalidSvgs << key;
             }
         }
         if (unwrittenFiles.size() == outputMap.size()) {
             qWarning().nospace() << "No files could be written for " << inputArg << ".";
         } else if (!unwrittenFiles.isEmpty()) {
             qWarning().nospace() << "The following files could not be written for " << inputArg << ":";
             qWarning().noquote() << joinedStrings(unwrittenFiles);
         }
         if (!invalidSvgs.isEmpty()) {
             qWarning().nospace() << "The following files written for " << inputArg << " are not valid SVGs:";
             qWarning().noquote() << joinedStrings(invalidSvgs);
         }
     }
 
     return wasAnyFileWritten ? 0 : 1;
 }