File indexing completed on 2024-12-15 04:00:59

 /*
  * SPDX-FileCopyrightText: 2019-2023 Mattia Basaglia <dev@dragon.best>
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
 #include "document_opener.hpp"
 
 #include <QMessageBox>
 
 #include "io/glaxnimate/glaxnimate_format.hpp"
 #include "utils/gzip.hpp"
 #include "model/assets/assets.hpp"
 #include "model/shapes/image.hpp"
 
 #include "widgets/dialogs/trace_dialog.hpp"
 
 #include "android_file_picker.hpp"
 #include "base_dialog.hpp"
 
 class glaxnimate::android::DocumentOpener::Private
 {
 public:
     QWidget* widget_parent;
 
     bool do_save_document(model::Composition *comp, const io::Options& opts, QIODevice& file)
     {
         return opts.format->save(file, opts.filename, comp, opts.settings);
     }
 
     std::unique_ptr<model::Document> from_raster(const QByteArray& data)
     {
         auto btn = QMessageBox::information(
             widget_parent,
             i18n("Open File"),
             i18n("Raster images need to be traced into vectors"),
             QMessageBox::Ok|QMessageBox::Cancel
         );
         if ( btn == QMessageBox::Cancel )
             return {};
 
         auto doc = std::make_unique<model::Document>("");
         auto main = doc->assets()->add_comp_no_undo();
         auto asset = doc->assets()->add_image(QImage::fromData(data));
         auto imageu = std::make_unique<model::Image>(doc.get());
         auto image = imageu.get();
         main->shapes.insert(std::move(imageu));
         main->width.set(asset->width.get());
         main->height.set(asset->height.get());
         QPointF pos(asset->width.get()/2., asset->height.get()/2.);
         image->transform->anchor_point.set(pos);
         image->transform->position.set(pos);
         image->image.set(asset);
 
         gui::TraceDialog dialog(image, widget_parent);
         DialogFixerFilter fixer(&dialog);
         if ( !dialog.exec() )
             return {};
 
         doc->assets()->images->values.remove(0);
         main->shapes.remove(main->shapes.index_of(image));
 
         return doc;
     }
 
 };
 
 glaxnimate::android::DocumentOpener::DocumentOpener(QWidget *widget_parent)
     : d(std::make_unique<Private>())
 {
     d->widget_parent = widget_parent;
 }
 
 glaxnimate::android::DocumentOpener::~DocumentOpener()
 {
 
 }
 
 bool glaxnimate::android::DocumentOpener::save(const QUrl &url, model::Composition* composition, io::Options &options) const
 {
     if ( !url.isValid() )
         return false;
 
     QString path = url.path();
     QFileInfo finfo(path);
 
     if ( !options.format )
         options.format = io::glaxnimate::GlaxnimateFormat::instance();
 
     if ( url.isLocalFile() )
     {
         options.filename = path;
         options.path = finfo.absoluteDir();
 
         QFile file(options.filename);
         return d->do_save_document(composition, options, file);
     }
     else
     {
         options.filename = url.toString();
         QByteArray data;
         QBuffer buf(&data);
         bool ok = d->do_save_document(composition, options, buf);
         if ( !ok || !AndroidFilePicker::write_content_uri(url, data) )
         {
             QMessageBox::warning(d->widget_parent, i18n("Save File"), i18n("Could not save the file"));
             return false;
         }
         return true;
     }
 }
 
 std::unique_ptr<glaxnimate::model::Document> glaxnimate::android::DocumentOpener::open(const QUrl &url) const
 {
     if ( !url.isValid() )
         return {};
 
     QString path = url.path();
     QFileInfo finfo(path);
     QString extension = finfo.suffix();
     io::Options options;
     options.format = io::IoRegistry::instance().from_extension(extension, io::ImportExport::Import);
 
     if ( url.isLocalFile() )
     {
         if ( !options.format )
         {
             QMessageBox::warning(d->widget_parent, i18n("Open File"), i18n("Unknown file type"));
             return {};
         }
         options.filename = path;
         options.path = finfo.absoluteDir();
         QFile file(options.filename);
 
         auto current_document = std::make_unique<model::Document>(options.filename);
         if ( !options.format->open(file, options.filename, current_document.get(), options.settings) )
             return {};
 
         current_document->set_io_options(options);
         return current_document;
     }
 
     options.filename = url.toString();
     QByteArray data = AndroidFilePicker::read_content_uri(url);
     bool zipped = false;
     if ( !options.format )
     {
         zipped = utils::gzip::is_compressed(data);
         if ( zipped )
         {
             QByteArray out;
             if ( !utils::gzip::decompress(data, out, {}) )
             {
                 QMessageBox::warning(d->widget_parent, i18n("Open File"), i18n("Could not unzip the file"));
                 return {};
             }
             data = std::move(out);
         }
 
         // json
         if ( data.startsWith('{') )
         {
             if ( data.contains("\"__type__\"") )
                 options.format = io::glaxnimate::GlaxnimateFormat::instance();
             else
                 options.format = io::IoRegistry::instance().from_slug("lottie");
         }
         else if ( data.contains("<svg") || data.contains("http://www.w3.org/2000/svg") )
         {
             options.format = io::IoRegistry::instance().from_slug("svg");
             options.settings["compressed"] = zipped;
         }
         else if ( data.startsWith("\x89PNG") )
         {
             return d->from_raster(data);
         }
     }
 
     if ( !options.format )
     {
 
         QString supported_formats;
         for ( const auto& fmt : io::IoRegistry::instance().importers() )
         {
             if ( fmt->slug() == "raster" )
                 continue;
             if ( !supported_formats.isEmpty() )
                 supported_formats += ",\n";
             supported_formats += fmt->name();
         }
         supported_formats += ",\nPNG";
 
         QMessageBox::warning(d->widget_parent, i18n("Open File"), i18n("Unknown file type. Supported files:\n%1", supported_formats));
         return {};
     }
 
     QBuffer file(&data);
     auto current_document = std::make_unique<model::Document>(options.filename);
     if ( !options.format->open(file, options.filename, current_document.get(), options.settings) )
     {
         QMessageBox::warning(d->widget_parent, i18n("Open File"), i18n("Error loading %1 file", options.format->slug()));
         return {};
     }
 
     if ( zipped && options.format->slug() == "lottie" )
         options.format = io::IoRegistry::instance().from_slug("tgs");
 
     current_document->set_io_options(options);
     return current_document;
 }
 
 std::unique_ptr<glaxnimate::model::Document> glaxnimate::android::DocumentOpener::from_raster(const QByteArray &data)
 {
     return d->from_raster(data);
 }