sp-gradient.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
#ifndef SEEN_SP_GRADIENT_H
#define SEEN_SP_GRADIENT_H
/*
 * Authors:
 *   Lauris Kaplinski <lauris@kaplinski.com>
 *   Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
 *   Jon A. Cruz <jon@joncruz.org>
 *
 * Copyrigt  (C) 2010 Jon A. Cruz
 * Copyright (C) 2007 Johan Engelen
 * Copyright (C) 1999-2002 Lauris Kaplinski
 * Copyright (C) 2000-2001 Ximian, Inc.
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#include <2geom/affine.h>
#include <cstddef>
#include <glibmm/ustring.h>
#include <sigc++/connection.h>
#include <vector>
 
#include "sp-paint-server.h"
#include "sp-gradient-spread.h"
#include "sp-gradient-units.h"
#include "sp-gradient-vector.h"
#include "sp-mesh-array.h"
 
class SPGradientReference;
class SPStop;
 
enum SPGradientType {
    SP_GRADIENT_TYPE_UNKNOWN,
    SP_GRADIENT_TYPE_LINEAR,
    SP_GRADIENT_TYPE_RADIAL,
    SP_GRADIENT_TYPE_MESH
};
 
enum SPGradientState {
    SP_GRADIENT_STATE_UNKNOWN,
    SP_GRADIENT_STATE_VECTOR,
    SP_GRADIENT_STATE_PRIVATE
};
 
enum GrPointType {
    POINT_LG_BEGIN = 0,
    POINT_LG_END,
    POINT_LG_MID,
    POINT_RG_CENTER,
    POINT_RG_R1,
    POINT_RG_R2,
    POINT_RG_FOCUS,
    POINT_RG_MID1,
    POINT_RG_MID2,
    POINT_MG_CORNER,
    POINT_MG_HANDLE,
    POINT_MG_TENSOR,
    // insert new point types here.
 
    POINT_G_INVALID
};
 
namespace Inkscape {
 
enum PaintTarget {
    FOR_FILL,
    FOR_STROKE
};
 
std::vector<PaintTarget> const &allPaintTargets();
 
} // namespace Inkscape
 
class SPGradient
    : public SPPaintServer
{
public:
    SPGradient();
    ~SPGradient() override;
    int tag() const override { return tag_of<decltype(*this)>; }
 
private:
    SPGradientUnits units;
    unsigned int units_set : 1;
public:
 
    Geom::Affine gradientTransform;
    unsigned int gradientTransform_set : 1;
 
private:
    SPGradientSpread spread;
    unsigned int spread_set : 1;
 
    unsigned int has_stops : 1;
 
    unsigned int has_patches : 1;
 
    bool _pinned = false;
 
public:
    SPGradientReference *ref;
 
    unsigned int state;
    
    mutable SPGradientVector vector;
    SPGradientVector const &getGradientVector() const;
 
    sigc::connection modified_connection;
 
    bool hasStops() const;
 
    SPStop* getFirstStop();
    int getStopCount() const;
 
    bool isEquivalent(SPGradient *b);
    bool isAligned(SPGradient *b);
 
    SPMeshNodeArray array;
    SPMeshNodeArray array_smoothed; // Smoothed version of array
    
    bool hasPatches() const;
 
 
    bool isUnitsSet() const;
    SPGradientUnits getUnits() const;
    void setUnits(SPGradientUnits units);
 
 
    bool isSpreadSet() const;
    SPGradientSpread getSpread() const;
 
    SPGradient *getVector(bool force_private = false);
    SPGradient const *getVector(bool force_private = false) const
    {
        return const_cast<SPGradient *>(this)->getVector(force_private);
    }
 
    SPGradient *getArray(bool force_private = false);
 
    //static GType getType();
 
    void ensureVector();
 
    void ensureArray();
 
    void setSpread(SPGradientSpread spread);
 
    SPGradientSpread fetchSpread() const;
    SPGradientUnits fetchUnits();
 
    void setSwatch(bool swatch = true);
    void setPinned(bool pinned = true);
    bool isPinned() const { return _pinned; }
 
    bool isSolid() const;
 
    static void gradientRefModified(SPObject *href, unsigned int flags, SPGradient *gradient);
    static void gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGradient *gr);
 
    /* Gradient repr methods */
    void repr_write_vector();
    void repr_clear_vector();
 
    cairo_pattern_t *create_preview_pattern(double width);
 
    Geom::Affine get_g2d_matrix(Geom::Affine const &ctm,
                                Geom::Rect const &bbox) const;
    Geom::Affine get_gs2d_matrix(Geom::Affine const &ctm,
                                 Geom::Rect const &bbox) const;
    void set_gs2d_matrix(Geom::Affine const &ctm, Geom::Rect const &bbox,
                         Geom::Affine const &gs2d);
 
    Geom::OptRect getAllItemsBox() const;
 
private:
    bool invalidateVector();
    bool invalidateArray();
    void rebuildVector() const;
    void rebuildArray();
 
protected:
    void build(SPDocument *document, Inkscape::XML::Node *repr) override;
    void release() override;
    void modified(unsigned int flags) override;
    Inkscape::XML::Node* write(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, unsigned int flags) override;
 
    void child_added(Inkscape::XML::Node *child, Inkscape::XML::Node *ref) override;
    void remove_child(Inkscape::XML::Node *child) override;
 
    void set(SPAttr key, char const *value) override;
};
 
void
sp_gradient_pattern_common_setup(cairo_pattern_t *cp,
                                 SPGradient *gr,
                                 Geom::OptRect const &bbox,
                                 double opacity);
 
#endif // SEEN_SP_GRADIENT_H
 
/*
  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:fileencoding=utf-8:textwidth=99 :