← Back to branch summary

~centralelyon2010/inkscape/imagelinks2

« back to all changes in this revision

Viewing changes to src/sp-paint-server.cpp

  • Committer: JazzyNico
  • Date: 2011-08-29 20:25:30 UTC
  • Revision ID: nicoduf@yahoo.fr-20110829202530-6deuoz11q90usldv
Code refactoring and merging with trunk (revision 10599).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sp-paint-server.cpp
14
14
 */
15
15
 
16
16
#include <string.h>
17
 
#include "libnr/nr-pixblock-pattern.h"
 
17
#include "sp-paint-server-reference.h"
18
18
#include "sp-paint-server.h"
19
19
 
20
20
#include "sp-gradient.h"
21
21
#include "xml/node.h"
22
22
 
23
23
static void sp_paint_server_class_init(SPPaintServerClass *psc);
24
 
static void sp_paint_server_init(SPPaintServer *ps);
25
 
 
26
 
static void sp_paint_server_release(SPObject *object);
27
 
 
28
 
static void sp_painter_stale_fill(SPPainter *painter, NRPixBlock *pb);
 
24
 
 
25
static cairo_pattern_t *sp_paint_server_create_dummy_pattern(SPPaintServer *ps, cairo_t *ct, Geom::OptRect const &bbox, double opacity);
29
26
 
30
27
static SPObjectClass *parent_class;
31
 
static GSList *stale_painters = NULL;
32
 
 
33
 
GType sp_paint_server_get_type (void)
 
28
 
 
29
SPPaintServer *SPPaintServerReference::getObject() const
 
30
{
 
31
    return static_cast<SPPaintServer *>(URIReference::getObject());
 
32
}
 
33
 
 
34
bool SPPaintServerReference::_acceptObject(SPObject *obj) const
 
35
{
 
36
    return SP_IS_PAINT_SERVER(obj);
 
37
}
 
38
 
 
39
GType SPPaintServer::get_type(void)
34
40
{
35
41
    static GType type = 0;
36
42
    if (!type) {
43
49
            NULL,       /* class_data */
44
50
            sizeof(SPPaintServer),
45
51
            16, /* n_preallocs */
46
 
            (GInstanceInitFunc) sp_paint_server_init,
 
52
            (GInstanceInitFunc) SPPaintServer::init,
47
53
            NULL,       /* value_table */
48
54
        };
49
55
        type = g_type_register_static(SP_TYPE_OBJECT, "SPPaintServer", &info, (GTypeFlags) 0);
53
59
 
54
60
static void sp_paint_server_class_init(SPPaintServerClass *psc)
55
61
{
56
 
    SPObjectClass *sp_object_class = (SPObjectClass *) psc;
57
 
    sp_object_class->release = sp_paint_server_release;
 
62
    psc->pattern_new = sp_paint_server_create_dummy_pattern;
 
63
 
58
64
    parent_class = (SPObjectClass *) g_type_class_ref(SP_TYPE_OBJECT);
59
65
}
60
66
 
61
 
static void sp_paint_server_init(SPPaintServer *ps)
62
 
{
63
 
    ps->painters = NULL;
64
 
}
65
 
 
66
 
static void sp_paint_server_release(SPObject *object)
67
 
{
68
 
    SPPaintServer *ps = SP_PAINT_SERVER(object);
69
 
 
70
 
    while (ps->painters) {
71
 
        SPPainter *painter = ps->painters;
72
 
        ps->painters = painter->next;
73
 
        stale_painters = g_slist_prepend(stale_painters, painter);
74
 
        painter->next = NULL;
75
 
        painter->server = NULL;
76
 
        painter->fill = sp_painter_stale_fill;
77
 
    }
78
 
 
79
 
    if (((SPObjectClass *) parent_class)->release) {
80
 
        ((SPObjectClass *) parent_class)->release(object);
81
 
    }
82
 
}
83
 
 
84
 
SPPainter *sp_paint_server_painter_new(SPPaintServer *ps,
85
 
                                       Geom::Matrix const &full_transform,
86
 
                                       Geom::Matrix const &parent_transform,
87
 
                                       const NRRect *bbox)
 
67
void SPPaintServer::init(SPPaintServer * /*ps*/)
 
68
{
 
69
}
 
70
 
 
71
cairo_pattern_t *sp_paint_server_create_pattern(SPPaintServer *ps,
 
72
                                                cairo_t *ct,
 
73
                                                Geom::OptRect const &bbox,
 
74
                                                double opacity)
88
75
{
89
76
    g_return_val_if_fail(ps != NULL, NULL);
90
77
    g_return_val_if_fail(SP_IS_PAINT_SERVER(ps), NULL);
91
 
    g_return_val_if_fail(bbox != NULL, NULL);
92
 
 
93
 
    SPPainter *painter = NULL;
94
 
    SPPaintServerClass *psc = (SPPaintServerClass *) G_OBJECT_GET_CLASS(ps);
95
 
    if ( psc->painter_new ) {
96
 
        painter = (*psc->painter_new)(ps, full_transform, parent_transform, bbox);
97
 
    }
98
 
 
99
 
    if (painter) {
100
 
        painter->next = ps->painters;
101
 
        painter->server = ps;
102
 
        painter->type = (SPPainterType) G_OBJECT_TYPE(ps);
103
 
        ps->painters = painter;
104
 
    }
105
 
 
106
 
    return painter;
107
 
}
108
 
 
109
 
static void sp_paint_server_painter_free(SPPaintServer *ps, SPPainter *painter)
110
 
{
111
 
    g_return_if_fail(ps != NULL);
112
 
    g_return_if_fail(SP_IS_PAINT_SERVER(ps));
113
 
    g_return_if_fail(painter != NULL);
114
 
 
115
 
    SPPaintServerClass *psc = (SPPaintServerClass *) G_OBJECT_GET_CLASS(ps);
116
 
 
117
 
    SPPainter *r = NULL;
118
 
    for (SPPainter *p = ps->painters; p != NULL; p = p->next) {
119
 
        if (p == painter) {
120
 
            if (r) {
121
 
                r->next = p->next;
122
 
            } else {
123
 
                ps->painters = p->next;
124
 
            }
125
 
            p->next = NULL;
126
 
            if (psc->painter_free) {
127
 
                (*psc->painter_free) (ps, painter);
128
 
            }
129
 
            return;
130
 
        }
131
 
        r = p;
132
 
    }
133
 
 
134
 
    g_assert_not_reached();
135
 
}
136
 
 
137
 
SPPainter *sp_painter_free(SPPainter *painter)
138
 
{
139
 
    g_return_val_if_fail(painter != NULL, NULL);
140
 
 
141
 
    if (painter->server) {
142
 
        sp_paint_server_painter_free(painter->server, painter);
143
 
    } else {
144
 
        SPPaintServerClass *psc = (SPPaintServerClass *) g_type_class_ref(painter->type);
145
 
        if (psc->painter_free)
146
 
            (*psc->painter_free)(NULL, painter);
147
 
        stale_painters = g_slist_remove(stale_painters, painter);
148
 
    }
149
 
 
150
 
    return NULL;
151
 
}
152
 
 
153
 
static void sp_painter_stale_fill(SPPainter */*painter*/, NRPixBlock *pb)
154
 
{
155
 
    nr_pixblock_render_gray_noise(pb, NULL);
 
78
 
 
79
    cairo_pattern_t *cp = NULL;
 
80
    SPPaintServerClass *psc = (SPPaintServerClass *) G_OBJECT_GET_CLASS(ps);
 
81
    if ( psc->pattern_new ) {
 
82
        cp = (*psc->pattern_new)(ps, ct, bbox, opacity);
 
83
    }
 
84
 
 
85
    return cp;
 
86
}
 
87
 
 
88
static cairo_pattern_t *
 
89
sp_paint_server_create_dummy_pattern(SPPaintServer */*ps*/,
 
90
                                     cairo_t */* ct */,
 
91
                                     Geom::OptRect const &/*bbox*/,
 
92
                                     double /* opacity */)
 
93
{
 
94
    cairo_pattern_t *cp = cairo_pattern_create_rgb(1.0, 0.0, 1.0);
 
95
    return cp;
156
96
}
157
97
 
158
98
bool SPPaintServer::isSwatch() const
159
99
{
160
 
    bool swatch = false;
161
 
    if (SP_IS_GRADIENT(this)) {
162
 
        SPGradient *grad = SP_GRADIENT(this);
163
 
        if ( SP_GRADIENT_HAS_STOPS(grad) ) {
164
 
            gchar const * attr = repr->attribute("osb:paint");
165
 
            if (attr && !strcmp(attr, "solid")) {
166
 
                swatch = true;
167
 
            }
168
 
        }
169
 
    }
170
100
    return swatch;
171
101
}
172
102
 
173
103
bool SPPaintServer::isSolid() const
174
104
{
175
105
    bool solid = false;
176
 
    if (SP_IS_GRADIENT(this)) {
 
106
    if (swatch && SP_IS_GRADIENT(this)) {
177
107
        SPGradient *grad = SP_GRADIENT(this);
178
 
        if ( SP_GRADIENT_HAS_STOPS(grad) && (grad->getStopCount() == 0) ) {
179
 
            gchar const * attr = repr->attribute("osb:paint");
180
 
            if (attr && !strcmp(attr, "solid")) {
181
 
                solid = true;
182
 
            }
 
108
        if ( grad->hasStops() && (grad->getStopCount() == 0) ) {
 
109
            solid = true;
183
110
        }
184
111
    }
185
112
    return solid;
186
113
}
187
114
 
188
 
 
189
 
 
190
 
 
191
115
/*
192
116
  Local Variables:
193
117
  mode:c++