← Back to branch summary

~ubuntu-branches/debian/experimental/inkscape/experimental

« back to all changes in this revision

Viewing changes to src/widgets/gradient-vector.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Viehmann
  • Date: 2008-09-09 23:29:02 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20080909232902-c50iujhk1w79u8e7
Tags: 0.46-2.1
http://bugs.debian.org/487623
* Non-maintainer upload.
* Add upstream patch fixing a crash in the open dialog
  in the zh_CN.utf8 locale. Closes: #487623.
  Thanks to Luca Bruno for the patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/widgets/gradient-vector.cpp
6
6
 * Authors:
7
7
 *   Lauris Kaplinski <lauris@kaplinski.com>
8
8
 *   bulia byak <buliabyak@users.sf.net>
 
9
 *   MenTaLguY <mental@rydia.net>
9
10
 *
10
11
 * Copyright (C) 2001-2002 Lauris Kaplinski
11
12
 * Copyright (C) 2001 Ximian, Inc.
12
13
 * Copyright (C) 2004 Monash University
13
14
 * Copyright (C) 2004 David Turner
 
15
 * Copyright (C) 2006 MenTaLguY
14
16
 *
15
17
 * Released under GNU GPL, read the file 'COPYING' for more information
16
18
 *
38
40
#include "svg/css-ostringstream.h"
39
41
#include "sp-stop.h"
40
42
 
 
43
#include <sigc++/functors/ptr_fun.h>
 
44
#include <sigc++/adaptors/bind.h>
 
45
 
41
46
enum {
42
47
        VECTOR_SET,
43
48
        LAST_SIGNAL
47
52
static void sp_gradient_vector_selector_init (SPGradientVectorSelector *gvs);
48
53
static void sp_gradient_vector_selector_destroy (GtkObject *object);
49
54
 
50
 
static void sp_gvs_gradient_release (SPGradient *gr, SPGradientVectorSelector *gvs);
 
55
static void sp_gvs_gradient_release (SPObject *obj, SPGradientVectorSelector *gvs);
51
56
static void sp_gvs_defs_release (SPObject *defs, SPGradientVectorSelector *gvs);
52
57
static void sp_gvs_defs_modified (SPObject *defs, guint flags, SPGradientVectorSelector *gvs);
53
58
 
108
113
        gvs->doc = NULL;
109
114
        gvs->gr = NULL;
110
115
 
 
116
        new (&gvs->gradient_release_connection) sigc::connection();
 
117
        new (&gvs->defs_release_connection) sigc::connection();
 
118
        new (&gvs->defs_modified_connection) sigc::connection();
 
119
 
111
120
        gvs->menu = gtk_option_menu_new ();
112
121
        gtk_widget_show (gvs->menu);
113
122
        gtk_box_pack_start (GTK_BOX (gvs), gvs->menu, TRUE, TRUE, 0);
121
130
        gvs = SP_GRADIENT_VECTOR_SELECTOR (object);
122
131
 
123
132
        if (gvs->gr) {
124
 
                sp_signal_disconnect_by_data (gvs->gr, gvs);
 
133
                gvs->gradient_release_connection.disconnect();
125
134
                gvs->gr = NULL;
126
135
        }
127
136
 
128
137
        if (gvs->doc) {
129
 
                sp_signal_disconnect_by_data (SP_DOCUMENT_DEFS (gvs->doc), gvs);
 
138
                gvs->defs_release_connection.disconnect();
 
139
                gvs->defs_modified_connection.disconnect();
130
140
                gvs->doc = NULL;
131
141
        }
132
142
 
 
143
        gvs->gradient_release_connection.~connection();
 
144
        gvs->defs_release_connection.~connection();
 
145
        gvs->defs_modified_connection.~connection();
 
146
 
133
147
        if (((GtkObjectClass *) (parent_class))->destroy)
134
148
                (* ((GtkObjectClass *) (parent_class))->destroy) (object);
135
149
}
168
182
        if (doc != gvs->doc) {
169
183
                /* Disconnect signals */
170
184
                if (gvs->gr) {
171
 
                        sp_signal_disconnect_by_data (gvs->gr, gvs);
172
 
                        g_signal_handlers_disconnect_matched (G_OBJECT(gvs->gr), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, gvs);
 
185
                        gvs->gradient_release_connection.disconnect();
173
186
                        gvs->gr = NULL;
174
187
                }
175
188
                if (gvs->doc) {
176
 
                        sp_signal_disconnect_by_data (SP_DOCUMENT_DEFS (gvs->doc), gvs);
 
189
                        gvs->defs_release_connection.disconnect();
 
190
                        gvs->defs_modified_connection.disconnect();
177
191
                        gvs->doc = NULL;
178
192
                }
179
193
                /* Connect signals */
180
194
                if (doc) {
181
 
                        g_signal_connect (G_OBJECT (SP_DOCUMENT_DEFS (doc)), "release", G_CALLBACK (sp_gvs_defs_release), gvs);
182
 
                        g_signal_connect (G_OBJECT (SP_DOCUMENT_DEFS (doc)), "modified", G_CALLBACK (sp_gvs_defs_modified), gvs);
 
195
                        gvs->defs_release_connection = SP_DOCUMENT_DEFS(doc)->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_defs_release), gvs));
 
196
                        gvs->defs_modified_connection = SP_DOCUMENT_DEFS(doc)->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gvs_defs_modified), gvs));
183
197
                }
184
198
                if (gr) {
185
 
                        g_signal_connect (G_OBJECT (gr), "release", G_CALLBACK (sp_gvs_gradient_release), gvs);
 
199
                        gvs->gradient_release_connection = gr->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_gradient_release), gvs));
186
200
                }
187
201
                gvs->doc = doc;
188
202
                gvs->gr = gr;
330
344
        /* fixme: Really we would want to use _set_vector */
331
345
        /* Detach old */
332
346
        if (gvs->gr) {
333
 
                sp_signal_disconnect_by_data (gvs->gr, gvs);
 
347
                gvs->gradient_release_connection.disconnect();
334
348
                gvs->gr = NULL;
335
349
        }
336
350
        /* Attach new */
337
351
        if (norm) {
338
 
                g_signal_connect (G_OBJECT (norm), "release", G_CALLBACK (sp_gvs_gradient_release), gvs);
339
 
                /* fixme: Connect 'modified'? (Lauris) */
340
 
                /* fixme: I think we do not need it (Lauris) */
 
352
                gvs->gradient_release_connection = norm->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_gradient_release), gvs));
341
353
                gvs->gr = norm;
342
354
        }
343
355
 
346
358
        if (norm != gr) {
347
359
                /* We do extra undo push here */
348
360
                /* If handler has already done it, it is just NOP */
349
 
                sp_document_done (SP_OBJECT_DOCUMENT (norm));
 
361
                // FIXME: looks like this is never a valid undo step, consider removing this
 
362
            sp_document_done (SP_OBJECT_DOCUMENT (norm), SP_VERB_CONTEXT_GRADIENT,
 
363
                              /* TODO: annotate */ "gradient-vector.cpp:350");
350
364
        }
351
365
}
352
366
 
353
367
static void
354
 
sp_gvs_gradient_release (SPGradient *gr, SPGradientVectorSelector *gvs)
 
368
sp_gvs_gradient_release (SPObject *obj, SPGradientVectorSelector *gvs)
355
369
{
356
370
        /* Disconnect gradient */
357
371
        if (gvs->gr) {
358
 
                sp_signal_disconnect_by_data (gvs->gr, gvs);
 
372
                gvs->gradient_release_connection.disconnect();
359
373
                gvs->gr = NULL;
360
374
        }
361
375
 
367
381
sp_gvs_defs_release (SPObject *defs, SPGradientVectorSelector *gvs)
368
382
{
369
383
        gvs->doc = NULL;
 
384
 
 
385
        gvs->defs_release_connection.disconnect();
 
386
        gvs->defs_modified_connection.disconnect();
 
387
 
370
388
        /* Disconnect gradient as well */
371
389
        if (gvs->gr) {
372
 
                sp_signal_disconnect_by_data (gvs->gr, gvs);
 
390
                gvs->gradient_release_connection.disconnect();
373
391
                gvs->gr = NULL;
374
392
        }
375
393
 
405
423
static void sp_gradient_vector_dialog_destroy (GtkObject *object, gpointer data);
406
424
 
407
425
static void sp_gradient_vector_widget_destroy (GtkObject *object, gpointer data);
408
 
static void sp_gradient_vector_gradient_release (SPGradient *gradient, GtkWidget *widget);
409
 
static void sp_gradient_vector_gradient_modified (SPGradient *gradient, guint flags, GtkWidget *widget);
 
426
static void sp_gradient_vector_gradient_release (SPObject *obj, GtkWidget *widget);
 
427
static void sp_gradient_vector_gradient_modified (SPObject *obj, guint flags, GtkWidget *widget);
410
428
static void sp_gradient_vector_color_dragged (SPColorSelector *csel, GtkObject *object);
411
429
static void sp_gradient_vector_color_changed (SPColorSelector *csel, GtkObject *object);
412
430
static void update_stop_list( GtkWidget *mnu, SPGradient *gradient, SPStop *new_stop);
446
464
                }
447
465
        }
448
466
 
 
467
        Inkscape::XML::Document *xml_doc;
 
468
        xml_doc = SP_OBJECT_REPR(gradient)->document();
 
469
 
449
470
        if (i < 1) {
450
471
                gchar c[64];
451
 
                sp_svg_write_color (c, 64, 0x00000000);
 
472
                sp_svg_write_color (c, sizeof(c), 0x00000000);
452
473
 
453
474
                Inkscape::CSSOStringStream os;
454
475
                os << "stop-color:" << c << ";stop-opacity:" << 1.0 << ";";
455
476
 
456
477
                Inkscape::XML::Node *child;
457
478
 
458
 
                child = sp_repr_new ("svg:stop");
 
479
                child = xml_doc->createElement("svg:stop");
459
480
                sp_repr_set_css_double(child, "offset", 0.0);
460
481
                child->setAttribute("style", os.str().c_str());
461
482
                SP_OBJECT_REPR (gradient)->addChild(child, NULL);
462
483
 
463
 
                child = sp_repr_new ("svg:stop");
 
484
                child = xml_doc->createElement("svg:stop");
464
485
                sp_repr_set_css_double(child, "offset", 1.0);
465
486
                child->setAttribute("style", os.str().c_str());
466
487
                SP_OBJECT_REPR (gradient)->addChild(child, NULL);
467
488
        }
468
489
        if (i < 2) {
469
490
                sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", 0.0);
470
 
                Inkscape::XML::Node *child = SP_OBJECT_REPR(stop)->duplicate();
 
491
                Inkscape::XML::Node *child = SP_OBJECT_REPR(stop)->duplicate(SP_OBJECT_REPR(gradient)->document());
471
492
                sp_repr_set_css_double(child, "offset", 1.0);
472
493
                SP_OBJECT_REPR(gradient)->addChild(child, SP_OBJECT_REPR (stop));
473
494
        }
574
595
        SPColorSelector *csel = (SPColorSelector*)g_object_get_data (G_OBJECT (tbl), "cselector");
575
596
        guint32 const c = sp_stop_get_rgba32(stop);
576
597
        csel->base->setAlpha(SP_RGBA32_A_F (c));
577
 
        SPColor color;
578
 
        sp_color_set_rgb_float (&color, SP_RGBA32_R_F (c), SP_RGBA32_G_F (c), SP_RGBA32_B_F (c));
 
598
        SPColor color( SP_RGBA32_R_F (c), SP_RGBA32_G_F (c), SP_RGBA32_B_F (c) );
579
599
        // set its color, from the stored array
580
600
        csel->base->setColor( color );
581
601
        GtkWidget *offspin = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "offspn"));
637
657
    stop->offset = adjustment->value;
638
658
    sp_repr_set_css_double(SP_OBJECT_REPR(stop), "offset", stop->offset);
639
659
 
640
 
    sp_document_done (SP_OBJECT_DOCUMENT (stop));
 
660
    sp_document_done (SP_OBJECT_DOCUMENT (stop), SP_VERB_CONTEXT_GRADIENT,
 
661
                                                        _("Change gradient stop offset"));
641
662
 
642
663
        blocked = FALSE;
643
664
}
679
700
        }
680
701
 
681
702
        if (next != NULL) {
682
 
                new_stop_repr = SP_OBJECT_REPR(stop)->duplicate();
 
703
                new_stop_repr = SP_OBJECT_REPR(stop)->duplicate(SP_OBJECT_REPR(gradient)->document());
683
704
                SP_OBJECT_REPR(gradient)->addChild(new_stop_repr, SP_OBJECT_REPR(stop));
684
705
        } else {
685
706
                next = stop;
686
 
                new_stop_repr = SP_OBJECT_REPR(sp_prev_stop(stop, gradient))->duplicate();
 
707
                new_stop_repr = SP_OBJECT_REPR(sp_prev_stop(stop, gradient))->duplicate(SP_OBJECT_REPR(gradient)->document());
687
708
                SP_OBJECT_REPR(gradient)->addChild(new_stop_repr, SP_OBJECT_REPR(sp_prev_stop(stop, gradient)));
688
709
        }
689
710
 
697
718
 
698
719
        Inkscape::CSSOStringStream os;
699
720
        gchar c[64];
700
 
        sp_svg_write_color (c, 64, cnew);
 
721
        sp_svg_write_color (c, sizeof(c), cnew);
701
722
        gdouble opacity = (gdouble) SP_RGBA32_A_F (cnew);
702
723
        os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";
703
724
        SP_OBJECT_REPR (newstop)->setAttribute("style", os.str().c_str());
 
725
    sp_repr_set_css_double( SP_OBJECT_REPR(newstop), "offset", (double)newstop->offset);
704
726
 
705
727
        sp_gradient_vector_widget_load_gradient (vb, gradient);
706
728
        Inkscape::GC::release(new_stop_repr);
709
731
        GtkWidget *offslide =GTK_WIDGET (g_object_get_data (G_OBJECT (vb), "offslide"));
710
732
        gtk_widget_set_sensitive (offslide, TRUE);
711
733
        gtk_widget_set_sensitive (GTK_WIDGET (offspin), TRUE);
712
 
        sp_document_done (SP_OBJECT_DOCUMENT (gradient));
 
734
        sp_document_done (SP_OBJECT_DOCUMENT (gradient), SP_VERB_CONTEXT_GRADIENT, 
 
735
                          _("Add gradient stop"));
713
736
}
714
737
 
715
738
static void
740
763
                SP_OBJECT_REPR(gradient)->removeChild(SP_OBJECT_REPR(stop));
741
764
                sp_gradient_vector_widget_load_gradient (vb, gradient);
742
765
                update_stop_list(GTK_WIDGET(mnu), gradient, NULL);
743
 
                sp_document_done (SP_OBJECT_DOCUMENT (gradient));
 
766
                sp_document_done (SP_OBJECT_DOCUMENT (gradient), SP_VERB_CONTEXT_GRADIENT, 
 
767
                                  _("Delete gradient stop"));
744
768
        }
745
769
 
746
770
}
832
856
 
833
857
 
834
858
        /* Signals */
835
 
        gtk_signal_connect (GTK_OBJECT (Offset_adj), "value_changed",
836
 
                                                                                        GTK_SIGNAL_FUNC (offadjustmentChanged), vb);
 
859
        gtk_signal_connect (GTK_OBJECT (Offset_adj), "value_changed", 
 
860
                            GTK_SIGNAL_FUNC (offadjustmentChanged), vb);
837
861
 
838
862
        // gtk_signal_connect (GTK_OBJECT (slider), "changed",  GTK_SIGNAL_FUNC (offsliderChanged), vb);
839
863
        gtk_widget_show (hb);
843
867
        f = gtk_frame_new (_("Stop Color"));
844
868
        gtk_widget_show (f);
845
869
        gtk_box_pack_start (GTK_BOX (vb), f, TRUE, TRUE, PAD);
846
 
        csel = (GtkWidget*)sp_color_selector_new (SP_TYPE_COLOR_NOTEBOOK, SP_COLORSPACE_TYPE_NONE);
 
870
        csel = (GtkWidget*)sp_color_selector_new (SP_TYPE_COLOR_NOTEBOOK);
847
871
        g_object_set_data (G_OBJECT (vb), "cselector", csel);
848
872
        gtk_widget_show (csel);
849
873
        gtk_container_add (GTK_CONTAINER (f), csel);
936
960
        SPGradient *old;
937
961
 
938
962
        old = (SPGradient*)g_object_get_data (G_OBJECT (widget), "gradient");
 
963
 
939
964
        if (old != gradient) {
 
965
                sigc::connection *release_connection;
 
966
                sigc::connection *modified_connection;
 
967
 
 
968
                release_connection = (sigc::connection *)g_object_get_data(G_OBJECT(widget), "gradient_release_connection");
 
969
                modified_connection = (sigc::connection *)g_object_get_data(G_OBJECT(widget), "gradient_modified_connection");
 
970
 
940
971
                if (old) {
 
972
                        g_assert( release_connection != NULL );
 
973
                        g_assert( modified_connection != NULL );
 
974
                        release_connection->disconnect();
 
975
                        modified_connection->disconnect();
941
976
                        sp_signal_disconnect_by_data (old, widget);
942
977
                }
 
978
 
943
979
                if (gradient) {
944
 
                        g_signal_connect (G_OBJECT (gradient), "release", G_CALLBACK (sp_gradient_vector_gradient_release), widget);
945
 
                        g_signal_connect (G_OBJECT (gradient), "modified", G_CALLBACK (sp_gradient_vector_gradient_modified), widget);
 
980
                        if (!release_connection) {
 
981
                                release_connection = new sigc::connection();
 
982
                        }
 
983
                        if (!modified_connection) {
 
984
                                modified_connection = new sigc::connection();
 
985
                        }
 
986
                        *release_connection = gradient->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gradient_vector_gradient_release), widget));
 
987
                        *modified_connection = gradient->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gradient_vector_gradient_modified), widget));
 
988
                } else {
 
989
                        if (release_connection) {
 
990
                                delete release_connection;
 
991
                                release_connection = NULL;
 
992
                        }
 
993
                        if (modified_connection) {
 
994
                                delete modified_connection;
 
995
                                modified_connection = NULL;
 
996
                        }
946
997
                }
 
998
 
 
999
                g_object_set_data(G_OBJECT(widget), "gradient_release_connection", release_connection);
 
1000
                g_object_set_data(G_OBJECT(widget), "gradient_modified_connection", modified_connection);
947
1001
        }
948
1002
 
949
1003
        g_object_set_data (G_OBJECT (widget), "gradient", gradient);
959
1013
                SPColorSelector *csel = SP_COLOR_SELECTOR(g_object_get_data (G_OBJECT (widget), "cselector"));
960
1014
                // set alpha
961
1015
                csel->base->setAlpha(SP_RGBA32_A_F (c));
962
 
                SPColor color;
963
 
                sp_color_set_rgb_float (&color, SP_RGBA32_R_F (c), SP_RGBA32_G_F (c), SP_RGBA32_B_F (c));
 
1016
                SPColor color( SP_RGBA32_R_F (c), SP_RGBA32_G_F (c), SP_RGBA32_B_F (c) );
964
1017
                // set color
965
1018
                csel->base->setColor( color );
966
1019
        }
975
1028
        // Once the user edits a gradient, it stops being auto-collectable
976
1029
        if (SP_OBJECT_REPR(gradient)->attribute("inkscape:collect")) {
977
1030
                SPDocument *document = SP_OBJECT_DOCUMENT (gradient);
978
 
                gboolean saved = sp_document_get_undo_sensitive(document);
979
 
                sp_document_set_undo_sensitive (document, FALSE);
 
1031
                bool saved = sp_document_get_undo_sensitive(document);
 
1032
                sp_document_set_undo_sensitive (document, false);
980
1033
                SP_OBJECT_REPR(gradient)->setAttribute("inkscape:collect", NULL);
981
1034
                sp_document_set_undo_sensitive (document, saved);
982
1035
        }
1027
1080
}
1028
1081
 
1029
1082
static void
1030
 
sp_gradient_vector_gradient_release (SPGradient *gradient, GtkWidget *widget)
 
1083
sp_gradient_vector_gradient_release (SPObject *object, GtkWidget *widget)
1031
1084
{
1032
1085
        sp_gradient_vector_widget_load_gradient (widget, NULL);
1033
1086
}
1034
1087
 
1035
1088
static void
1036
 
sp_gradient_vector_gradient_modified (SPGradient *gradient, guint flags, GtkWidget *widget)
 
1089
sp_gradient_vector_gradient_modified (SPObject *object, guint flags, GtkWidget *widget)
1037
1090
{
 
1091
        SPGradient *gradient=SP_GRADIENT(object);
1038
1092
        if (!blocked) {
1039
1093
                blocked = TRUE;
1040
1094
                sp_gradient_vector_widget_load_gradient (widget, gradient);
1068
1122
    csel->base->getColorAlpha(stop->specified_color, &stop->opacity);
1069
1123
    stop->currentColor = false;
1070
1124
 
1071
 
        blocked = FALSE;
1072
 
    SPColorPreview *cpv = (SPColorPreview *)g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "preview");
1073
 
    sp_color_preview_set_rgba32(cpv, sp_stop_get_rgba32(stop));
1074
 
 
 
1125
    blocked = FALSE;
1075
1126
}
1076
1127
 
1077
1128
static void
1105
1156
 
1106
1157
        csel = (SPColorSelector*)g_object_get_data (G_OBJECT (object), "cselector");
1107
1158
        csel->base->getColorAlpha( color, &alpha );
1108
 
        rgb = sp_color_get_rgba32_ualpha (&color, 0x00);
 
1159
        rgb = color.toRGBA32( 0x00 );
1109
1160
 
1110
1161
        sp_repr_set_css_double (SP_OBJECT_REPR (stop), "offset", stop->offset);
1111
1162
        Inkscape::CSSOStringStream os;
1112
1163
        gchar c[64];
1113
 
        sp_svg_write_color (c, 64, rgb);
 
1164
        sp_svg_write_color (c, sizeof(c), rgb);
1114
1165
        os << "stop-color:" << c << ";stop-opacity:" << (gdouble) alpha <<";";
1115
1166
        SP_OBJECT_REPR (stop)->setAttribute("style", os.str().c_str());
1116
1167
                //      g_snprintf (c, 256, "stop-color:#%06x;stop-opacity:%g;", rgb >> 8, (gdouble) alpha);
1117
1168
                //SP_OBJECT_REPR (stop)->setAttribute("style", c);
1118
1169
 
1119
 
        sp_document_done (SP_OBJECT_DOCUMENT (ngr));
 
1170
        sp_document_done (SP_OBJECT_DOCUMENT (ngr), SP_VERB_CONTEXT_GRADIENT,
 
1171
                          _("Change gradient stop color"));
1120
1172
 
1121
1173
        blocked = FALSE;
 
1174
 
 
1175
        SPColorPreview *cpv = (SPColorPreview *)g_object_get_data (G_OBJECT(gtk_menu_get_active (GTK_MENU(gtk_option_menu_get_menu (mnu)))), "preview");
 
1176
        sp_color_preview_set_rgba32(cpv, sp_stop_get_rgba32(stop));
1122
1177
}
 
1178
 
 
1179
/*
 
1180
  Local Variables:
 
1181
  mode:c++
 
1182
  c-file-style:"stroustrup"
 
1183
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 
1184
  indent-tabs-mode:nil
 
1185
  fill-column:99
 
1186
  End:
 
1187
*/
 
1188
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :