gimpgrad.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Authors:
 *   Ted Gould <ted@gould.cx>
 *   Abhishek Sharma
 *
 * Copyright (C) 2004-2005 Authors
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#include "io/sys.h"
#include "extension/system.h"
#include "svg/css-ostringstream.h"
 
#include "colors/color.h"
#include "colors/manager.h"
#include "gimpgrad.h"
#include "streq.h"
#include "strneq.h"
#include "document.h"
#include "extension/extension.h"
 
using namespace Inkscape::Colors;
 
namespace Inkscape::Extension::Internal {
 
bool GimpGrad::load(Inkscape::Extension::Extension *)
{
    return true;
}
 
void GimpGrad::unload(Inkscape::Extension::Extension *)
{
    return;
}
 
static void append_css_num(Glib::ustring &str, double const num)
{
    CSSOStringStream stream;
    stream << num;
    str += stream.str();
}
 
static Glib::ustring stop_svg(Color const &in_color, double const location)
{
    Glib::ustring ret("<stop stop-color=\"");
 
    ret += in_color.converted(Space::Type::RGB)->toString(false);
    ret += '"';
 
    if (in_color[3] != 1) {
        ret += " stop-opacity=\"";
        append_css_num(ret, in_color.getOpacity());
        ret += '"';
    }
    ret += " offset=\"";
    append_css_num(ret, location);
    ret += "\"/>\n";
    return ret;
}
 
std::unique_ptr<SPDocument> GimpGrad::open(Inkscape::Extension::Input *, char const *filename, bool)
{
    Inkscape::IO::dump_fopen_call(filename, "I");
    FILE *gradient = Inkscape::IO::fopen_utf8name(filename, "r");
    if (gradient == nullptr) {
        return nullptr;
    }
 
    {
        char tempstr[1024];
        if (fgets(tempstr, 1024, gradient) == nullptr) {
            // std::cout << "Seems that the read failed" << std::endl;
            goto error;
        }
        if (!streq(tempstr, "GIMP Gradient\n")) {
            // std::cout << "This doesn't appear to be a GIMP gradient" << std::endl;
            goto error;
        }
 
        /* Name field. */
        if (fgets(tempstr, 1024, gradient) == nullptr) {
            // std::cout << "Seems that the second read failed" << std::endl;
            goto error;
        }
        if (!strneq(tempstr, "Name: ", 6)) {
            goto error;
        }
        /* Handle very long names.  (And also handle nul bytes gracefully: don't use strlen.) */
        while (memchr(tempstr, '\n', sizeof(tempstr) - 1) == nullptr) {
            if (fgets(tempstr, sizeof(tempstr), gradient) == nullptr) {
                goto error;
            }
        }
 
        /* n. segments */
        if (fgets(tempstr, 1024, gradient) == nullptr) {
            // std::cout << "Seems that the third read failed" << std::endl;
            goto error;
        }
        char *endptr = nullptr;
        long const n_segs = strtol(tempstr, &endptr, 10);
        if ((*endptr != '\n')
            || n_segs < 1) {
            /* SVG gradients are allowed to have zero stops (treated as `none'), but gimp 2.2
             * requires at least one segment (i.e. at least two stops) (see gimp_gradient_load in
             * gimpgradient-load.c).  We try to use the same error handling as gimp, so that
             * .ggr files that work in one program work in both programs. */
            goto error;
        }
 
        Color prev_color(0x0);
        Glib::ustring outsvg("<svg><defs><linearGradient>\n");
        long n_segs_found = 0;
        double prev_right = 0.0;
        while (fgets(tempstr, 1024, gradient) != nullptr) {
            double dbls[3 + 4 + 4];
            gchar *p = tempstr;
            for (double & dbl : dbls) {
                gchar *end = nullptr;
                double const xi = g_ascii_strtod(p, &end);
                if (!end || end == p || !g_ascii_isspace(*end)) {
                    goto error;
                }
                if (xi < 0 || 1 < xi) {
                    goto error;
                }
                dbl = xi;
                p = end + 1;
            }
 
            double const left = dbls[0];
            if (left != prev_right) {
                goto error;
            }
            double const middle = dbls[1];
            if (!(left <= middle)) {
                goto error;
            }
            double const right = dbls[2];
            if (!(middle <= right)) {
                goto error;
            }
 
            g_assert(11 == G_N_ELEMENTS(dbls));
            auto leftcolor = Color(Space::Type::RGB, {dbls[3], dbls[4], dbls[5], dbls[6]});
            auto rightcolor = Color(Space::Type::RGB, {dbls[7], dbls[8], dbls[9], dbls[10]});
 
            /* Interpolation enums: curve shape and colour space. */
            {
                /* TODO: Currently we silently ignore type & color, assuming linear interpolation in
                 * sRGB space (or whatever the default in SVG is).  See gimp/app/core/gimpgradient.c
                 * for how gimp uses these.  We could use gimp functions to sample at a few points, and
                 * add some intermediate stops to convert to the linear/sRGB interpolation */
                int type; /* enum: linear, curved, sine, sphere increasing, sphere decreasing. */
                int color_interpolation; /* enum: rgb, hsv anticlockwise, hsv clockwise. */
                if (sscanf(p, "%8d %8d", &type, &color_interpolation) != 2) {
                    continue;
                }
            }
 
            if (prev_color != leftcolor) {
                outsvg += stop_svg(leftcolor, left);
            }
            if (fabs(middle - .5 * (left + right)) > 1e-4) {
                outsvg += stop_svg(leftcolor.averaged(rightcolor), middle);
            }
            outsvg += stop_svg(rightcolor, right);
 
            prev_color = rightcolor;
            prev_right = right;
            ++n_segs_found;
        }
        if (prev_right != 1.0) {
            goto error;
        }
 
        if (n_segs_found != n_segs) {
            goto error;
        }
 
        outsvg += "</linearGradient></defs></svg>";
 
        // std::cout << "SVG Output: " << outsvg << std::endl;
 
        fclose(gradient);
 
        return SPDocument::createNewDocFromMem(outsvg.raw(), true);
    }
 
error:
    fclose(gradient);
    return nullptr;
}
 
#include "clear-n_.h"
 
void GimpGrad::init()
{
    // clang-format off
    Inkscape::Extension::build_from_mem(
        "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
            "<name>" N_("GIMP Gradients") "</name>\n"
            "<id>org.inkscape.input.gimpgrad</id>\n"
            "<input>\n"
                "<extension>.ggr</extension>\n"
                "<mimetype>application/x-gimp-gradient</mimetype>\n"
                "<filetypename>" N_("GIMP Gradient (*.ggr)") "</filetypename>\n"
                "<filetypetooltip>" N_("Gradients used in GIMP") "</filetypetooltip>\n"
            "</input>\n"
        "</inkscape-extension>\n", std::make_unique<GimpGrad>());
    // clang-format on
    return;
}
 
} // namespace Inkscape::Extension::Internal
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :