source: synfigstudio/trunk/fuentes/src/gui/states/state_star.cpp @ 481

Last change on this file since 481 was 481, checked in by jrpelegrina, 4 years ago

First release to xenial

File size: 54.6 KB
Line 
1/* === S Y N F I G ========================================================= */
2/*!     \file state_star.cpp
3**      \brief Template File
4**
5**      $Id$
6**
7**      \legal
8**      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9**      Copyright (c) 2008 Chris Moore
10**  Copyright (c) 2010 Carlos López
11**
12**      This package is free software; you can redistribute it and/or
13**      modify it under the terms of the GNU General Public License as
14**      published by the Free Software Foundation; either version 2 of
15**      the License, or (at your option) any later version.
16**
17**      This package is distributed in the hope that it will be useful,
18**      but WITHOUT ANY WARRANTY; without even the implied warranty of
19**      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20**      General Public License for more details.
21**      \endlegal
22*/
23/* ========================================================================= */
24
25/* === H E A D E R S ======================================================= */
26
27#ifdef USING_PCH
28#       include "pch.h"
29#else
30#ifdef HAVE_CONFIG_H
31#       include <config.h>
32#endif
33
34#include <synfig/valuenodes/valuenode_dynamiclist.h>
35#include <synfigapp/action_system.h>
36#include <synfig/valuenodes/valuenode_bline.h>
37
38#include "state_star.h"
39#include "state_normal.h"
40#include "canvasview.h"
41#include "workarea.h"
42#include "app.h"
43
44#include <synfigapp/action.h>
45#include "event_mouse.h"
46#include "event_layerclick.h"
47#include "docks/dock_toolbox.h"
48#include "docks/dialog_tooloptions.h"
49#include "duck.h"
50#include "widgets/widget_enum.h"
51#include "widgets/widget_distance.h"
52#include <synfigapp/main.h>
53
54#include "general.h"
55
56#endif
57
58/* === U S I N G =========================================================== */
59
60using namespace std;
61using namespace etl;
62using namespace synfig;
63using namespace studio;
64
65/* === M A C R O S ========================================================= */
66
67#ifndef LAYER_CREATION
68#define LAYER_CREATION(button, stockid, tooltip)        \
69        { \
70                Gtk::Image *icon = manage(new Gtk::Image(Gtk::StockID(stockid), \
71                        Gtk::ICON_SIZE_SMALL_TOOLBAR)); \
72                button.add(*icon); \
73        } \
74        button.set_relief(Gtk::RELIEF_NONE); \
75        button.set_tooltip_text(tooltip) ;\
76        button.signal_toggled().connect(sigc::mem_fun(*this, \
77                &studio::StateStar_Context::toggle_layer_creation))
78#endif
79
80// indentation for options layout
81#ifndef SPACING
82#define SPACING(name, px) \
83        Gtk::Alignment *name = Gtk::manage(new Gtk::Alignment()); \
84        name->set_size_request(px)
85#endif
86
87#define GAP     (3)
88#define INDENTATION (6)
89
90/* === G L O B A L S ======================================================= */
91
92StateStar studio::state_star;
93
94/* === C L A S S E S & S T R U C T S ======================================= */
95
96class studio::StateStar_Context : public sigc::trackable
97{
98        etl::handle<CanvasView> canvas_view_;
99        CanvasView::IsWorking is_working;
100
101        Duckmatic::Push duckmatic_push;
102
103        Point point_holder;
104
105        etl::handle<Duck> point2_duck;
106
107        void refresh_ducks();
108
109        bool prev_workarea_layer_status_;
110
111        //Toolbox settings
112        synfigapp::Settings& settings;
113
114        // holder of options
115        Gtk::Table options_table;
116
117        // title
118        Gtk::Label title_label;
119
120        // layer name:
121        Gtk::Label id_label;
122        Gtk::HBox id_box;
123        Gtk::Entry id_entry;
124
125        // layer types to create:
126        Gtk::Label layer_types_label;
127        Gtk::ToggleButton layer_star_togglebutton;
128        Gtk::ToggleButton layer_region_togglebutton;
129        Gtk::ToggleButton layer_outline_togglebutton;
130        Gtk::ToggleButton layer_advanced_outline_togglebutton;
131        Gtk::ToggleButton layer_curve_gradient_togglebutton;
132        Gtk::ToggleButton layer_plant_togglebutton;
133        Gtk::HBox layer_types_box;
134
135        // blend method
136        Gtk::Label blend_label;
137        Gtk::HBox blend_box;
138        Widget_Enum blend_enum;
139
140        // opacity
141        Gtk::Label opacity_label;
142        Gtk::HScale opacity_hscl;
143
144        // brush size
145        Gtk::Label bline_width_label;
146        Widget_Distance bline_width_dist;
147
148        // star points
149        Gtk::Label number_of_points_label;
150        Glib::RefPtr<Gtk::Adjustment> number_of_points_adj;
151        Gtk::SpinButton number_of_points_spin;
152
153        // radius ratio
154        Gtk::Label radius_ratio_label;
155        Glib::RefPtr<Gtk::Adjustment> radius_ratio_adj;
156        Gtk::SpinButton radius_ratio_spin;
157
158        // angle offset
159        Gtk::Label angle_offset_label;
160        Glib::RefPtr<Gtk::Adjustment> angle_offset_adj;
161        Gtk::SpinButton angle_offset_spin;
162        Gtk::HBox angle_offset_box;
163
164        // regular polygon
165        Gtk::Label regular_polygon_label;
166        Gtk::CheckButton regular_polygon_checkbutton;
167        Gtk::HBox regular_polygon_box;
168
169        // inner width
170        Gtk::Label outer_width_label;
171        Glib::RefPtr<Gtk::Adjustment> outer_width_adj;
172        Gtk::SpinButton outer_width_spin;
173
174        // inner tangent
175        Gtk::Label inner_tangent_label;
176        Glib::RefPtr<Gtk::Adjustment> inner_tangent_adj;
177        Gtk::SpinButton inner_tangent_spin;
178
179        // outer width
180        Gtk::Label inner_width_label;
181        Glib::RefPtr<Gtk::Adjustment> inner_width_adj;
182        Gtk::SpinButton inner_width_spin;
183
184        // outer tangent
185        Gtk::Label outer_tangent_label;
186        Glib::RefPtr<Gtk::Adjustment> outer_tangent_adj;
187        Gtk::SpinButton outer_tangent_spin;
188
189        // invert
190        Gtk::Label invert_label;
191        Gtk::CheckButton invert_checkbutton;
192        Gtk::HBox invert_box;
193
194        // feather size
195        Gtk::Label feather_label;
196        Widget_Distance feather_dist;
197
198        // link origins
199        Gtk::Label link_origins_label;
200        Gtk::CheckButton layer_link_origins_checkbutton;
201        Gtk::HBox link_origins_box;
202
203        // spline origins at center
204        Gtk::Label origins_at_center_label;
205        Gtk::CheckButton layer_origins_at_center_checkbutton;
206        Gtk::HBox origins_at_center_box;
207
208public:
209
210        // this only counts the layers which will have their origins linked
211        int layers_to_create()const
212        {
213                return
214                        (get_layer_star_flag() && get_layer_origins_at_center_flag()) +
215                        get_layer_region_flag() +
216                        get_layer_outline_flag() +
217                        get_layer_advanced_outline_flag() +
218                        get_layer_curve_gradient_flag() +
219                        get_layer_plant_flag();
220        }
221
222        synfig::String get_id()const { return id_entry.get_text(); }
223        void set_id(const synfig::String& x) { return id_entry.set_text(x); }
224
225        int get_blend()const { return blend_enum.get_value(); }
226        void set_blend(int x) { return blend_enum.set_value(x); }
227
228        Real get_opacity()const { return opacity_hscl.get_value(); }
229        void set_opacity(Real x) { opacity_hscl.set_value(x); }
230
231        Real get_bline_width() const {
232                return bline_width_dist.get_value().get(
233                        Distance::SYSTEM_UNITS,
234                        get_canvas_view()->get_canvas()->rend_desc()
235                );
236        }
237        void set_bline_width(Distance x) { return bline_width_dist.set_value(x);}
238
239        Real get_feather_size() const {
240                return feather_dist.get_value().get(
241                        Distance::SYSTEM_UNITS,
242                        get_canvas_view()->get_canvas()->rend_desc()
243                );
244        }
245        void set_feather_size(Distance x) { return feather_dist.set_value(x);}
246
247        Real get_number_of_points()const { return number_of_points_adj->get_value(); }
248        void set_number_of_points(Real f) { number_of_points_adj->set_value(f); }
249
250        Real get_inner_tangent()const { return inner_tangent_adj->get_value(); }
251        void set_inner_tangent(Real f) { inner_tangent_adj->set_value(f); }
252
253        Real get_outer_tangent()const { return outer_tangent_adj->get_value(); }
254        void set_outer_tangent(Real f) { outer_tangent_adj->set_value(f); }
255
256        Real get_inner_width()const { return inner_width_adj->get_value(); }
257        void set_inner_width(Real f) { inner_width_adj->set_value(f); }
258
259        Real get_outer_width()const { return outer_width_adj->get_value(); }
260        void set_outer_width(Real f) { outer_width_adj->set_value(f); }
261
262        Real get_radius_ratio()const { return radius_ratio_adj->get_value(); }
263        void set_radius_ratio(Real f) { radius_ratio_adj->set_value(f); }
264
265        Real get_angle_offset()const { return angle_offset_adj->get_value(); }
266        void set_angle_offset(Real f) { angle_offset_adj->set_value(f); }
267
268        bool get_invert()const { return invert_checkbutton.get_active(); }
269        void set_invert(bool i) { invert_checkbutton.set_active(i); }
270
271        bool get_regular_polygon()const { return regular_polygon_checkbutton.get_active(); }
272        void set_regular_polygon(bool i) { regular_polygon_checkbutton.set_active(i); }
273
274        bool get_layer_star_flag()const { return layer_star_togglebutton.get_active(); }
275        void set_layer_star_flag(bool x) { return layer_star_togglebutton.set_active(x); }
276
277        bool get_layer_region_flag()const { return layer_region_togglebutton.get_active(); }
278        void set_layer_region_flag(bool x) { return layer_region_togglebutton.set_active(x); }
279
280        bool get_layer_outline_flag()const { return layer_outline_togglebutton.get_active(); }
281        void set_layer_outline_flag(bool x) { return layer_outline_togglebutton.set_active(x); }
282
283        bool get_layer_advanced_outline_flag()const { return layer_advanced_outline_togglebutton.get_active(); }
284        void set_layer_advanced_outline_flag(bool x) { return layer_advanced_outline_togglebutton.set_active(x); }
285
286        bool get_layer_curve_gradient_flag()const { return layer_curve_gradient_togglebutton.get_active(); }
287        void set_layer_curve_gradient_flag(bool x) { return layer_curve_gradient_togglebutton.set_active(x); }
288
289        bool get_layer_plant_flag()const { return layer_plant_togglebutton.get_active(); }
290        void set_layer_plant_flag(bool x) { return layer_plant_togglebutton.set_active(x); }
291
292        bool get_layer_link_origins_flag()const { return layer_link_origins_checkbutton.get_active(); }
293        void set_layer_link_origins_flag(bool x) { return layer_link_origins_checkbutton.set_active(x); }
294
295        bool get_layer_origins_at_center_flag()const { return layer_origins_at_center_checkbutton.get_active(); }
296        void set_layer_origins_at_center_flag(bool x) { return layer_origins_at_center_checkbutton.set_active(x); }
297
298  bool layer_star_flag;
299  bool layer_region_flag;
300  bool layer_outline_flag;
301  bool layer_advanced_outline_flag;
302  bool layer_curve_gradient_flag;
303  bool layer_plant_flag;
304
305        void refresh_tool_options(); //to refresh the toolbox
306
307        //events
308        Smach::event_result event_stop_handler(const Smach::event& x);
309        Smach::event_result event_refresh_handler(const Smach::event& x);
310        Smach::event_result event_mouse_click_handler(const Smach::event& x);
311        Smach::event_result event_refresh_tool_options(const Smach::event& x);
312
313        //constructor destructor
314        StateStar_Context(CanvasView* canvas_view);
315        ~StateStar_Context();
316
317        //Canvas interaction
318        const etl::handle<CanvasView>& get_canvas_view()const{return canvas_view_;}
319        etl::handle<synfigapp::CanvasInterface> get_canvas_interface()const{return canvas_view_->canvas_interface();}
320        synfig::Canvas::Handle get_canvas()const{return canvas_view_->get_canvas();}
321        WorkArea * get_work_area()const{return canvas_view_->get_work_area();}
322
323        //Modifying settings etc.
324        void load_settings();
325        void save_settings();
326        void reset();
327        void increment_id();
328        bool egress_on_selection_change;
329        Smach::event_result event_layer_selection_changed_handler(const Smach::event& /*x*/)
330        {
331                if(egress_on_selection_change)
332                        throw &state_normal;
333                return Smach::RESULT_OK;
334        }
335
336        void make_star(const Point& p1, const Point& p2);
337
338        void toggle_layer_creation();
339
340};      // END of class StateStar_Context
341
342/* === M E T H O D S ======================================================= */
343
344StateStar::StateStar():
345        Smach::state<StateStar_Context>("star")
346{
347        insert(event_def(EVENT_LAYER_SELECTION_CHANGED,&StateStar_Context::event_layer_selection_changed_handler));
348        insert(event_def(EVENT_STOP,&StateStar_Context::event_stop_handler));
349        insert(event_def(EVENT_REFRESH,&StateStar_Context::event_refresh_handler));
350        insert(event_def(EVENT_REFRESH_DUCKS,&StateStar_Context::event_refresh_handler));
351        insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DOWN,&StateStar_Context::event_mouse_click_handler));
352        insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DRAG,&StateStar_Context::event_mouse_click_handler));
353        insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_UP,&StateStar_Context::event_mouse_click_handler));
354        insert(event_def(EVENT_REFRESH_TOOL_OPTIONS,&StateStar_Context::event_refresh_tool_options));
355}
356
357StateStar::~StateStar()
358{
359}
360
361void
362StateStar_Context::load_settings()
363{
364        try
365        {
366                synfig::ChangeLocale change_locale(LC_NUMERIC, "C");
367                String value;
368
369                //parse the arguments yargh!
370                if(settings.get_value("star.id",value))
371                        set_id(value);
372                else
373                        set_id("Star");
374
375                if(settings.get_value("star.blend",value) && value != "")
376                        set_blend(atoi(value.c_str()));
377                else
378                        set_blend(0);//(int)Color::BLEND_COMPOSITE); //0 should be blend composites value
379
380                if(settings.get_value("star.opacity",value))
381                        set_opacity(atof(value.c_str()));
382                else
383                        set_opacity(1);
384
385                if(settings.get_value("star.bline_width",value) && value != "")
386                        set_bline_width(Distance(atof(value.c_str()), App::distance_system));
387                else
388                        set_bline_width(Distance(1, App::distance_system)); // default width
389
390                if(settings.get_value("star.feather",value))
391                        set_feather_size(Distance(atof(value.c_str()), App::distance_system));
392                else
393                        set_feather_size(Distance(0, App::distance_system)); // default feather
394
395                if(settings.get_value("star.number_of_points",value))
396                        set_number_of_points(atof(value.c_str()));
397                else
398                        set_number_of_points(5);
399
400                if(settings.get_value("star.inner_tangent",value))
401                        set_inner_tangent(atof(value.c_str()));
402                else
403                        set_inner_tangent(0);
404
405                if(settings.get_value("star.outer_tangent",value))
406                        set_outer_tangent(atof(value.c_str()));
407                else
408                        set_outer_tangent(0);
409
410                if(settings.get_value("star.inner_width",value))
411                        set_inner_width(atof(value.c_str()));
412                else
413                        set_inner_width(1);
414
415                if(settings.get_value("star.outer_width",value))
416                        set_outer_width(atof(value.c_str()));
417                else
418                        set_outer_width(1);
419
420                if(settings.get_value("star.radius_ratio",value))
421                        set_radius_ratio(atof(value.c_str()));
422                else
423                        set_radius_ratio(0.5);
424
425                if(settings.get_value("star.angle_offset",value))
426                        set_angle_offset(atof(value.c_str()));
427                else
428                        set_angle_offset(0);
429
430                if(settings.get_value("star.invert",value) && value != "0")
431                        set_invert(true);
432                else
433                        set_invert(false);
434
435                if(settings.get_value("star.regular_polygon",value) && value != "0")
436                        set_regular_polygon(true);
437                else
438                        set_regular_polygon(false);
439
440                if(settings.get_value("star.layer_star",value) && value=="0")
441                        set_layer_star_flag(false);
442                else
443                        set_layer_star_flag(true);
444
445                if(settings.get_value("star.layer_region",value) && value=="1")
446                        set_layer_region_flag(true);
447                else
448                        set_layer_region_flag(false);
449
450                if(settings.get_value("star.layer_outline",value) && value=="1")
451                        set_layer_outline_flag(true);
452                else
453                        set_layer_outline_flag(false);
454
455                if(settings.get_value("star.layer_advanced_outline",value) && value=="1")
456                        set_layer_advanced_outline_flag(true);
457                else
458                        set_layer_advanced_outline_flag(false);
459
460                if(settings.get_value("star.layer_curve_gradient",value) && value=="1")
461                        set_layer_curve_gradient_flag(true);
462                else
463                        set_layer_curve_gradient_flag(false);
464
465                if(settings.get_value("star.layer_plant",value) && value=="1")
466                        set_layer_plant_flag(true);
467                else
468                        set_layer_plant_flag(false);
469
470                if(settings.get_value("star.layer_link_origins",value) && value=="0")
471                        set_layer_link_origins_flag(false);
472                else
473                        set_layer_link_origins_flag(true);
474
475                if(settings.get_value("star.layer_origins_at_center",value) && value=="0")
476                        set_layer_origins_at_center_flag(false);
477                else
478                        set_layer_origins_at_center_flag(true);
479
480          // determine layer flags
481                layer_star_flag = get_layer_star_flag();
482          layer_region_flag = get_layer_region_flag();
483          layer_outline_flag = get_layer_outline_flag();
484          layer_advanced_outline_flag = get_layer_outline_flag();
485          layer_curve_gradient_flag = get_layer_curve_gradient_flag();
486          layer_plant_flag = get_layer_plant_flag();
487        }
488        catch(...)
489        {
490                synfig::warning("State Star: Caught exception when attempting to load settings.");
491        }
492}
493
494void
495StateStar_Context::save_settings()
496{
497        try
498        {
499                synfig::ChangeLocale change_locale(LC_NUMERIC, "C");
500                settings.set_value("star.id",get_id());
501                settings.set_value("star.blend",strprintf("%d",get_blend()));
502                settings.set_value("star.opacity",strprintf("%f",(float)get_opacity()));
503                settings.set_value("star.bline_width", bline_width_dist.get_value().get_string());
504                settings.set_value("star.feather", feather_dist.get_value().get_string());
505                settings.set_value("star.number_of_points",strprintf("%d",(int)(get_number_of_points() + 0.5)));
506                settings.set_value("star.inner_tangent",strprintf("%f",(float)get_inner_tangent()));
507                settings.set_value("star.outer_tangent",strprintf("%f",(float)get_outer_tangent()));
508                settings.set_value("star.inner_width",strprintf("%f",(float)get_inner_width()));
509                settings.set_value("star.outer_width",strprintf("%f",(float)get_outer_width()));
510                settings.set_value("star.radius_ratio",strprintf("%f",(float)get_radius_ratio()));
511                settings.set_value("star.angle_offset",strprintf("%f",(float)get_angle_offset()));
512                settings.set_value("star.invert",get_invert()?"1":"0");
513                settings.set_value("star.regular_polygon",get_regular_polygon()?"1":"0");
514                settings.set_value("star.layer_star",get_layer_star_flag()?"1":"0");
515                settings.set_value("star.layer_outline",get_layer_outline_flag()?"1":"0");
516                settings.set_value("star.layer_advanced_outline",get_layer_advanced_outline_flag()?"1":"0");
517                settings.set_value("star.layer_region",get_layer_region_flag()?"1":"0");
518                settings.set_value("star.layer_curve_gradient",get_layer_curve_gradient_flag()?"1":"0");
519                settings.set_value("star.layer_plant",get_layer_plant_flag()?"1":"0");
520                settings.set_value("star.layer_link_origins",get_layer_link_origins_flag()?"1":"0");
521                settings.set_value("star.layer_origins_at_center",get_layer_origins_at_center_flag()?"1":"0");
522        }
523        catch(...)
524        {
525                synfig::warning("State Star: Caught exception when attempting to save settings.");
526        }
527}
528
529void
530StateStar_Context::reset()
531{
532        refresh_ducks();
533}
534
535void
536StateStar_Context::increment_id()
537{
538        String id(get_id());
539        int number=1;
540        int digits=0;
541
542        if(id.empty())
543                id="Star";
544
545        // If there is a number
546        // already at the end of the
547        // id, then remove it.
548        if(id[id.size()-1]<='9' && id[id.size()-1]>='0')
549        {
550                // figure out how many digits it is
551                for (digits = 0;
552                         (int)id.size()-1 >= digits && id[id.size()-1-digits] <= '9' && id[id.size()-1-digits] >= '0';
553                         digits++)
554                        ;
555
556                String str_number;
557                str_number=String(id,id.size()-digits,id.size());
558                id=String(id,0,id.size()-digits);
559
560                number=atoi(str_number.c_str());
561        }
562        else
563        {
564                number=1;
565                digits=3;
566        }
567
568        number++;
569
570        // Add the number back onto the id
571        {
572                const String format(strprintf("%%0%dd",digits));
573                id+=strprintf(format.c_str(),number);
574        }
575
576        // Set the ID
577        set_id(id);
578}
579
580StateStar_Context::StateStar_Context(CanvasView* canvas_view):
581        canvas_view_(canvas_view),
582        is_working(*canvas_view),
583        duckmatic_push(get_work_area()),
584        prev_workarea_layer_status_(get_work_area()->get_allow_layer_clicks()),
585        settings(synfigapp::Main::get_selected_input_device()->settings()),
586        opacity_hscl(0.0f, 1.01f, 0.01f),
587        number_of_points_adj(Gtk::Adjustment::create(0, 2, 120, 1, 1)),
588        number_of_points_spin(number_of_points_adj,1,0),
589        radius_ratio_adj(Gtk::Adjustment::create(0, -10, 10, 0.01, 0.1)),
590        radius_ratio_spin(radius_ratio_adj,1,2),
591        angle_offset_adj(Gtk::Adjustment::create(0, -360, 360, 0.1, 1)),
592        angle_offset_spin(angle_offset_adj,1,1),
593        outer_width_adj(Gtk::Adjustment::create(0, -10, 10, 0.01, 0.1)),
594        outer_width_spin(outer_width_adj,1,2),
595        inner_tangent_adj(Gtk::Adjustment::create(0,-10, 10, 0.01, 0.1)),
596        inner_tangent_spin(inner_tangent_adj,1,2),
597        inner_width_adj(Gtk::Adjustment::create(0, -10, 10, 0.01, 0.1)),
598        inner_width_spin(inner_width_adj,1,2),
599        outer_tangent_adj(Gtk::Adjustment::create(0,-10, 10, 0.01, 0.1)),
600        outer_tangent_spin(outer_tangent_adj,1,2)
601{
602        egress_on_selection_change=true;
603
604        /* Set up the tool options dialog */
605
606        // 0, title
607        title_label.set_label(_("Star Creation"));
608        Pango::AttrList list;
609        Pango::AttrInt attr = Pango::Attribute::create_attr_weight(Pango::WEIGHT_BOLD);
610        list.insert(attr);
611        title_label.set_attributes(list);
612        title_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
613
614        // 1, layer name label and entry
615        id_label.set_label(_("Name:"));
616        id_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
617        SPACING(id_gap, GAP);
618        id_box.pack_start(id_label, Gtk::PACK_SHRINK);
619        id_box.pack_start(*id_gap, Gtk::PACK_SHRINK);
620
621        id_box.pack_start(id_entry);
622
623        // 2, layer types creation
624        layer_types_label.set_label(_("Layer Type:"));
625        layer_types_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
626
627        LAYER_CREATION(layer_star_togglebutton,
628                ("synfig-layer_geometry_star"), _("Create a star layer"));
629
630        LAYER_CREATION(layer_region_togglebutton,
631                ("synfig-layer_geometry_region"), _("Create a region layer"));
632
633        LAYER_CREATION(layer_outline_togglebutton,
634                ("synfig-layer_geometry_outline"), _("Create a outline layer"));
635
636        LAYER_CREATION(layer_advanced_outline_togglebutton,
637                ("synfig-layer_geometry_advanced_outline"), _("Create a advanced outline layer"));
638
639        LAYER_CREATION(layer_plant_togglebutton,
640                ("synfig-layer_other_plant"), _("Create a plant layer"));
641
642        LAYER_CREATION(layer_curve_gradient_togglebutton,
643                ("synfig-layer_gradient_curve"), _("Create a gradient layer"));
644
645        SPACING(layer_types_indent, INDENTATION);
646
647        layer_types_box.pack_start(*layer_types_indent, Gtk::PACK_SHRINK);
648        layer_types_box.pack_start(layer_star_togglebutton, Gtk::PACK_SHRINK);
649        layer_types_box.pack_start(layer_region_togglebutton, Gtk::PACK_SHRINK);
650        layer_types_box.pack_start(layer_outline_togglebutton, Gtk::PACK_SHRINK);
651        layer_types_box.pack_start(layer_advanced_outline_togglebutton, Gtk::PACK_SHRINK);
652        layer_types_box.pack_start(layer_plant_togglebutton, Gtk::PACK_SHRINK);
653        layer_types_box.pack_start(layer_curve_gradient_togglebutton, Gtk::PACK_SHRINK);
654
655        // 3, blend method label and dropdown list
656        blend_label.set_label(_("Blend Method:"));
657        blend_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
658        SPACING(blend_gap, GAP);
659        blend_box.pack_start(blend_label, Gtk::PACK_SHRINK);
660        blend_box.pack_start(*blend_gap, Gtk::PACK_SHRINK);
661
662        blend_enum.set_param_desc(ParamDesc(Color::BLEND_COMPOSITE,"blend_method")
663                .set_local_name(_("Blend Method"))
664                .set_description(_("Defines the blend method to be used for stars")));
665
666        // 4, opacity label and slider
667        opacity_label.set_label(_("Opacity:"));
668        opacity_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
669
670        opacity_hscl.set_digits(2);
671        opacity_hscl.set_value_pos(Gtk::POS_LEFT);
672        opacity_hscl.set_tooltip_text(_("Opacity"));
673
674        // 5, brush size
675        bline_width_label.set_label(_("Brush Size:"));
676        bline_width_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
677        bline_width_label.set_sensitive(false);
678
679        bline_width_dist.set_digits(2);
680        bline_width_dist.set_range(0,10000000);
681        bline_width_dist.set_sensitive(false);
682
683        // 6, star points
684        number_of_points_label.set_label(_("Star Points:"));
685        number_of_points_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
686
687        // 7, angle offset
688        SPACING(angle_offset_indent, INDENTATION);
689        angle_offset_label.set_label(_("Offset:"));
690        angle_offset_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
691        angle_offset_box.pack_start(*angle_offset_indent, Gtk::PACK_SHRINK);
692        angle_offset_box.pack_start(angle_offset_label, Gtk::PACK_SHRINK);
693
694        // 8, radius ratio
695        radius_ratio_label.set_label(_("Radius Ratio:"));
696        radius_ratio_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
697
698        // 9, regular polygon
699        regular_polygon_label.set_label(_("Regular Polygon"));
700        regular_polygon_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
701
702        regular_polygon_box.pack_start(regular_polygon_label);
703        regular_polygon_box.pack_end(regular_polygon_checkbutton, Gtk::PACK_SHRINK);
704
705        // 10, inner width
706        inner_width_label.set_label(_("Inner Width:"));
707        inner_width_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
708
709        // 11, inner tangent
710        inner_tangent_label.set_label(_("Inner Tangent:"));
711        inner_tangent_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
712
713        // 12, outer width
714        outer_width_label.set_label(_("Outer Width:"));
715        outer_width_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
716
717        // 13, outer tangent
718        outer_tangent_label.set_label(_("Outer Tangent:"));
719        outer_tangent_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
720
721        // 14, invert
722        invert_label.set_label(_("Invert"));
723        invert_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
724
725        invert_box.pack_start(invert_label);
726        invert_box.pack_end(invert_checkbutton, Gtk::PACK_SHRINK);
727        invert_box.set_sensitive(false);
728
729        // 15, feather
730        feather_label.set_label(_("Feather:"));
731        feather_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
732        feather_label.set_sensitive(false);
733
734        feather_dist.set_digits(2);
735        feather_dist.set_range(0,10000000);
736        feather_dist.set_sensitive(false);
737
738        // 16, link origins
739        link_origins_label.set_label(_("Link Origins"));
740        link_origins_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
741
742        link_origins_box.pack_start(link_origins_label);
743        link_origins_box.pack_end(layer_link_origins_checkbutton, Gtk::PACK_SHRINK);
744        link_origins_box.set_sensitive(false);
745
746        // 17, spline origins at center
747        origins_at_center_label.set_label(_("Spline Origins at Center"));
748        origins_at_center_label.set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
749
750        origins_at_center_box.pack_start(origins_at_center_label);
751        origins_at_center_box.pack_end(layer_origins_at_center_checkbutton, Gtk::PACK_SHRINK);
752        origins_at_center_box.set_sensitive(false);
753
754        load_settings();
755
756        // pack all options to the options_table
757
758        // 0, title
759        options_table.attach(title_label,
760                0, 2, 0, 1, Gtk::FILL, Gtk::FILL, 0, 0
761                );
762        // 1, name
763        options_table.attach(id_box,
764                0, 2, 1, 2, Gtk::FILL, Gtk::FILL, 0, 0
765                );
766        // 2, layer types creation
767        options_table.attach(layer_types_label,
768                0, 2, 2, 3, Gtk::FILL, Gtk::FILL, 0, 0
769                );
770        options_table.attach(layer_types_box,
771                0, 2, 3, 4, Gtk::FILL, Gtk::FILL, 0, 0
772                );
773        // 3, blend method
774        options_table.attach(blend_box,
775                0, 1, 4, 5, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
776                );
777        options_table.attach(blend_enum,
778                1, 2, 4, 5, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
779                );
780        // 4, opacity
781        options_table.attach(opacity_label,
782                0, 1, 5, 6, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
783                );
784        options_table.attach(opacity_hscl,
785                1, 2, 5, 6, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
786                );
787        // 5, brush size
788        options_table.attach(bline_width_label,
789                0, 1, 6, 7, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
790                );
791        options_table.attach(bline_width_dist,
792                1, 2, 6, 7, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
793                );
794        // 6, star points
795        options_table.attach(number_of_points_label,
796                0, 1, 7, 8, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
797                );
798        options_table.attach(number_of_points_spin,
799                1, 2, 7, 8, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
800                );
801        // 7, star points offset
802        options_table.attach(angle_offset_box,
803                0, 1, 8, 9, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
804                );
805        options_table.attach(angle_offset_spin,
806                1, 2, 8, 9, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
807                );
808        // 8, radius ratio
809        options_table.attach(radius_ratio_label,
810                0, 1, 9, 10, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
811                );
812        options_table.attach(radius_ratio_spin,
813                1, 2, 9, 10, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
814                );
815        // 9, regular polygon
816        options_table.attach(regular_polygon_box,
817                0, 2, 10, 11, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
818                );
819        // 10, inner width
820        options_table.attach(inner_width_label,
821                0, 1, 11, 12, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
822                );
823        options_table.attach(inner_width_spin,
824                1, 2, 11, 12, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
825                );
826        // 11, inner tangent
827        options_table.attach(inner_tangent_label,
828                0, 1, 12, 13, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
829                );
830        options_table.attach(inner_tangent_spin,
831                1, 2, 12, 13, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
832                );
833        // 12, outer width
834        options_table.attach(outer_width_label,
835                0, 1, 13, 14, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
836                );
837        options_table.attach(outer_width_spin,
838                1, 2, 13, 14, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
839                );
840        // 13, outer tangent
841        options_table.attach(outer_tangent_label,
842                0, 1, 14, 15, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
843                );
844        options_table.attach(outer_tangent_spin,
845                1, 2, 14, 15, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
846                );
847        // 14, invert
848        options_table.attach(invert_box,
849                0, 2, 15, 16, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
850                );
851        // 15, feather
852        options_table.attach(feather_label,
853                0, 1, 16, 17, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
854                );
855        options_table.attach(feather_dist,
856                1, 2, 16, 17, Gtk::EXPAND|Gtk::FILL, Gtk::FILL, 0, 0
857                );
858        // 16, link origins
859        options_table.attach(link_origins_box,
860                0, 2, 17, 18, Gtk::FILL, Gtk::FILL, 0, 0
861                );
862        // 17, origins at center
863        options_table.attach(origins_at_center_box,
864                0, 2, 18, 19, Gtk::FILL, Gtk::FILL, 0, 0
865                );
866
867        // fine-tune options layout
868        options_table.set_border_width(GAP*2); // border width
869        options_table.set_row_spacings(GAP); // row gap
870        options_table.set_row_spacing(0, GAP*2); // the gap between first and second row.
871        options_table.set_row_spacing(2, 1); // row gap between label and icon of layer type
872        options_table.set_row_spacing(19, 0); // the final row using border width of table
873
874        options_table.show_all();
875
876        refresh_tool_options();
877        App::dialog_tool_options->present();
878
879        // Turn off layer clicking
880        get_work_area()->set_allow_layer_clicks(false);
881
882        // clear out the ducks
883        get_work_area()->clear_ducks();
884
885        // Refresh the work area
886        get_work_area()->queue_draw();
887
888        get_work_area()->set_cursor(Gdk::STAR);
889
890        App::dock_toolbox->refresh();
891}
892
893void
894StateStar_Context::refresh_tool_options()
895{
896        App::dialog_tool_options->clear();
897        App::dialog_tool_options->set_widget(options_table);
898        App::dialog_tool_options->set_local_name(_("Star Tool"));
899        App::dialog_tool_options->set_name("star");
900}
901
902Smach::event_result
903StateStar_Context::event_refresh_tool_options(const Smach::event& /*x*/)
904{
905        refresh_tool_options();
906        return Smach::RESULT_ACCEPT;
907}
908
909StateStar_Context::~StateStar_Context()
910{
911        save_settings();
912
913        // Restore layer clicking
914        get_work_area()->set_allow_layer_clicks(prev_workarea_layer_status_);
915        get_work_area()->reset_cursor();
916
917        App::dialog_tool_options->clear();
918
919        // Refresh the work area
920        get_work_area()->queue_draw();
921
922        get_canvas_view()->queue_rebuild_ducks();
923
924        App::dock_toolbox->refresh();
925}
926
927Smach::event_result
928StateStar_Context::event_stop_handler(const Smach::event& /*x*/)
929{
930        throw &state_normal;
931        return Smach::RESULT_OK;
932}
933
934Smach::event_result
935StateStar_Context::event_refresh_handler(const Smach::event& /*x*/)
936{
937        refresh_ducks();
938        return Smach::RESULT_ACCEPT;
939}
940
941void
942StateStar_Context::make_star(const Point& _p1, const Point& _p2)
943{
944        synfigapp::Action::PassiveGrouper group(get_canvas_interface()->get_instance().get(),_("New Star"));
945        synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
946
947        Layer::Handle layer;
948
949        Canvas::Handle canvas;
950        int depth(0);
951
952        // we are temporarily using the layer to hold something
953        layer=get_canvas_view()->get_selection_manager()->get_selected_layer();
954        if(layer)
955        {
956                depth=layer->get_depth();
957                canvas=layer->get_canvas();
958        }
959
960        synfigapp::SelectionManager::LayerList layer_selection;
961        if (!getenv("SYNFIG_TOOLS_CLEAR_SELECTION"))
962                layer_selection = get_canvas_view()->get_selection_manager()->get_selected_layers();
963
964        const synfig::TransformStack& transform(get_work_area()->get_curr_transform_stack());
965        const Point p1(transform.unperform(_p1));
966        const Point p2(transform.unperform(_p2));
967
968        Real radius_ratio(get_radius_ratio());
969        Real radius1((p2-p1).mag());
970        Real radius2(radius1 * radius_ratio);
971        int points = get_number_of_points();
972        Real inner_tangent = get_inner_tangent() * radius1;
973        Real outer_tangent = get_outer_tangent() * radius2;
974        Real inner_width = get_inner_width();
975        Real outer_width = get_outer_width();
976        Angle::deg offset(get_angle_offset());
977        bool regular(get_regular_polygon());
978        Angle::deg angle(360.0/points);
979        Vector origin;
980        Real x, y;
981
982        if (get_layer_origins_at_center_flag())
983        {
984                x = y = 0;
985                origin = p1;
986        }
987        else
988        {
989                x = p1[0];
990                y = p1[1];
991        }
992
993        std::vector<BLinePoint> new_list;
994        int point(0);
995        for (int i = 0; i < points; i++)
996        {
997                new_list.push_back(*(new BLinePoint));
998                new_list[point].set_width(outer_width);
999                new_list[point].set_vertex(Point(radius1*Angle::cos(angle*i + offset).get() + x,
1000                                                                                 radius1*Angle::sin(angle*i + offset).get() + y));
1001                new_list[point++].set_tangent(Point(-Angle::sin(angle*i + offset).get(),
1002                                                                                         Angle::cos(angle*i + offset).get()) * outer_tangent);
1003
1004                if (!regular)
1005                {
1006                        new_list.push_back(*(new BLinePoint));
1007                        new_list[point].set_width(inner_width);
1008                        new_list[point].set_vertex(Point(radius2*Angle::cos(angle*i + angle/2 + offset).get() + x,
1009                                                                                         radius2*Angle::sin(angle*i + angle/2 + offset).get() + y));
1010                        new_list[point++].set_tangent(Point(-Angle::sin(angle*i + angle/2 + offset).get(),
1011                                                                                                 Angle::cos(angle*i + angle/2 + offset).get()) * inner_tangent);
1012                }
1013        }
1014
1015        ValueNode_BLine::Handle value_node_bline(ValueNode_BLine::create(new_list));
1016        assert(value_node_bline);
1017
1018        ValueNode::Handle value_node_origin(ValueNode_Const::create(origin));
1019        assert(value_node_origin);
1020
1021        // Set the looping flag
1022        value_node_bline->set_loop(true);
1023
1024        if(!canvas)
1025                canvas=get_canvas_view()->get_canvas();
1026
1027        value_node_bline->set_member_canvas(canvas);
1028
1029        // count how many layers we're going to be creating
1030        int layers_to_create = this->layers_to_create();
1031
1032        ///////////////////////////////////////////////////////////////////////////
1033        //   S T A R
1034        ///////////////////////////////////////////////////////////////////////////
1035
1036        if (get_layer_star_flag())
1037        {
1038                egress_on_selection_change=false;
1039                layer=get_canvas_interface()->add_layer_to("star",canvas,depth);
1040                egress_on_selection_change=true;
1041                if (!layer)
1042                {
1043                        get_canvas_view()->get_ui_interface()->error(_("Unable to create layer"));
1044                        group.cancel();
1045                        return;
1046                }
1047                layer_selection.push_back(layer);
1048
1049                layer->set_param("amount",get_opacity());
1050                get_canvas_interface()->signal_layer_param_changed()(layer,"amount");
1051
1052                layer->set_param("blend_method",get_blend());
1053                get_canvas_interface()->signal_layer_param_changed()(layer,"blend_method");
1054
1055                layer->set_param("radius1",radius1);
1056                get_canvas_interface()->signal_layer_param_changed()(layer,"radius1");
1057
1058                layer->set_param("radius2",radius2);
1059                get_canvas_interface()->signal_layer_param_changed()(layer,"radius2");
1060
1061                layer->set_param("angle",offset);
1062                get_canvas_interface()->signal_layer_param_changed()(layer,"angle");
1063
1064                layer->set_param("points",points);
1065                get_canvas_interface()->signal_layer_param_changed()(layer,"points");
1066
1067                layer->set_param("regular_polygon",regular);
1068                get_canvas_interface()->signal_layer_param_changed()(layer,"regular_polygon");
1069
1070                layer->set_param("feather",get_feather_size());
1071                get_canvas_interface()->signal_layer_param_changed()(layer,"feather");
1072
1073                layer->set_param("invert",get_invert());
1074                get_canvas_interface()->signal_layer_param_changed()(layer,"invert");
1075
1076                layer->set_description(get_id());
1077                get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
1078
1079                // only link the star's origin parameter if the option is selected, we're putting bline
1080                // origins at their centers, and we're creating more than one layer
1081                if (get_layer_link_origins_flag() && get_layer_origins_at_center_flag() && layers_to_create > 1)
1082                {
1083                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1084                        assert(action);
1085
1086                        action->set_param("canvas",get_canvas());
1087                        action->set_param("canvas_interface",get_canvas_interface());
1088                        action->set_param("layer",layer);
1089                        if(!action->set_param("param",String("origin")))
1090                                synfig::error("LayerParamConnect didn't like \"param\"");
1091                        if(!action->set_param("value_node",ValueNode::Handle(value_node_origin)))
1092                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1093
1094                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1095                        {
1096                                group.cancel();
1097                                throw String(_("Unable to create Star layer"));
1098                                return;
1099                        }
1100                }
1101                else
1102                {
1103                        layer->set_param("origin",p1);
1104                        get_canvas_interface()->signal_layer_param_changed()(layer,"origin");
1105                }
1106        }
1107
1108        ///////////////////////////////////////////////////////////////////////////
1109        //   C U R V E   G R A D I E N T
1110        ///////////////////////////////////////////////////////////////////////////
1111
1112        if(get_layer_curve_gradient_flag())
1113        {
1114                synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
1115
1116                egress_on_selection_change=false;
1117                Layer::Handle layer(get_canvas_interface()->add_layer_to("curve_gradient",canvas,depth));
1118                egress_on_selection_change=true;
1119                if (!layer)
1120                {
1121                        get_canvas_view()->get_ui_interface()->error(_("Unable to create layer"));
1122                        group.cancel();
1123                        return;
1124                }
1125                layer_selection.push_back(layer);
1126
1127                layer->set_description(get_id()+_(" Gradient"));
1128                get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
1129
1130                layer->set_param("amount",get_opacity());
1131                get_canvas_interface()->signal_layer_param_changed()(layer,"amount");
1132
1133                layer->set_param("blend_method",get_blend());
1134                get_canvas_interface()->signal_layer_param_changed()(layer,"blend_method");
1135
1136                layer->set_param("width",get_bline_width());
1137                get_canvas_interface()->signal_layer_param_changed()(layer,"width");
1138
1139                {
1140                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1141                        assert(action);
1142
1143                        action->set_param("canvas",get_canvas());
1144                        action->set_param("canvas_interface",get_canvas_interface());
1145                        action->set_param("layer",layer);
1146                        if(!action->set_param("param",String("bline")))
1147                                synfig::error("LayerParamConnect didn't like \"param\"");
1148                        if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
1149                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1150
1151                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1152                        {
1153                                //get_canvas_view()->get_ui_interface()->error(_("Unable to create BLine layer"));
1154                                group.cancel();
1155                                throw String(_("Unable to create Gradient layer"));
1156                                return;
1157                        }
1158                }
1159
1160                // only link the curve gradient's origin parameter if the option is selected and we're creating more than one layer
1161                if (get_layer_link_origins_flag() && layers_to_create > 1)
1162                {
1163                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1164                        assert(action);
1165
1166                        action->set_param("canvas",get_canvas());
1167                        action->set_param("canvas_interface",get_canvas_interface());
1168                        action->set_param("layer",layer);
1169                        if(!action->set_param("param",String("origin")))
1170                                synfig::error("LayerParamConnect didn't like \"param\"");
1171                        if(!action->set_param("value_node",ValueNode::Handle(value_node_origin)))
1172                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1173
1174                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1175                        {
1176                                group.cancel();
1177                                throw String(_("Unable to create Gradient layer"));
1178                                return;
1179                        }
1180                }
1181                else
1182                {
1183                        layer->set_param("origin",origin);
1184                        get_canvas_interface()->signal_layer_param_changed()(layer,"origin");
1185                }
1186        }
1187
1188        ///////////////////////////////////////////////////////////////////////////
1189        //   P L A N T
1190        ///////////////////////////////////////////////////////////////////////////
1191
1192        if(get_layer_plant_flag())
1193        {
1194                synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
1195
1196                egress_on_selection_change=false;
1197                Layer::Handle layer(get_canvas_interface()->add_layer_to("plant",canvas,depth));
1198                egress_on_selection_change=true;
1199                if (!layer)
1200                {
1201                        get_canvas_view()->get_ui_interface()->error(_("Unable to create layer"));
1202                        group.cancel();
1203                        return;
1204                }
1205                layer_selection.push_back(layer);
1206                layer->set_description(get_id()+_(" Plant"));
1207                get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
1208
1209                layer->set_param("amount",get_opacity());
1210                get_canvas_interface()->signal_layer_param_changed()(layer,"amount");
1211
1212                layer->set_param("blend_method",get_blend());
1213                get_canvas_interface()->signal_layer_param_changed()(layer,"blend_method");
1214
1215                {
1216                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1217                        assert(action);
1218
1219                        action->set_param("canvas",get_canvas());
1220                        action->set_param("canvas_interface",get_canvas_interface());
1221                        action->set_param("layer",layer);
1222                        if(!action->set_param("param",String("bline")))
1223                                synfig::error("LayerParamConnect didn't like \"param\"");
1224                        if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
1225                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1226
1227                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1228                        {
1229                                group.cancel();
1230                                throw String(_("Unable to create Plant layer"));
1231                                return;
1232                        }
1233                }
1234
1235                // only link the plant's origin parameter if the option is selected and we're creating more than one layer
1236                if (get_layer_link_origins_flag() && layers_to_create > 1)
1237                {
1238                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1239                        assert(action);
1240
1241                        action->set_param("canvas",get_canvas());
1242                        action->set_param("canvas_interface",get_canvas_interface());
1243                        action->set_param("layer",layer);
1244                        if(!action->set_param("param",String("origin")))
1245                                synfig::error("LayerParamConnect didn't like \"param\"");
1246                        if(!action->set_param("value_node",ValueNode::Handle(value_node_origin)))
1247                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1248
1249                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1250                        {
1251                                group.cancel();
1252                                throw String(_("Unable to create Plant layer"));
1253                                return;
1254                        }
1255                }
1256                else
1257                {
1258                        layer->set_param("origin",origin);
1259                        get_canvas_interface()->signal_layer_param_changed()(layer,"origin");
1260                }
1261        }
1262
1263        ///////////////////////////////////////////////////////////////////////////
1264        //   R E G I O N
1265        ///////////////////////////////////////////////////////////////////////////
1266
1267        if(get_layer_region_flag())
1268        {
1269                synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
1270
1271                egress_on_selection_change=false;
1272                Layer::Handle layer(get_canvas_interface()->add_layer_to("region",canvas,depth));
1273                egress_on_selection_change=true;
1274                if (!layer)
1275                {
1276                        get_canvas_view()->get_ui_interface()->error(_("Unable to create layer"));
1277                        group.cancel();
1278                        return;
1279                }
1280                layer_selection.push_back(layer);
1281                layer->set_description(get_id()+_(" Region"));
1282                get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
1283
1284                layer->set_param("amount",get_opacity());
1285                get_canvas_interface()->signal_layer_param_changed()(layer,"amount");
1286
1287                layer->set_param("blend_method",get_blend());
1288                get_canvas_interface()->signal_layer_param_changed()(layer,"blend_method");
1289
1290                layer->set_param("feather",get_feather_size());
1291                get_canvas_interface()->signal_layer_param_changed()(layer,"feather");
1292
1293                layer->set_param("invert",get_invert());
1294                get_canvas_interface()->signal_layer_param_changed()(layer,"invert");
1295
1296                // I don't know if it's safe to reuse the same LayerParamConnect action, so I'm
1297                // using 2 separate ones.
1298                {
1299                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1300                        assert(action);
1301
1302                        action->set_param("canvas",get_canvas());
1303                        action->set_param("canvas_interface",get_canvas_interface());
1304                        action->set_param("layer",layer);
1305                        if(!action->set_param("param",String("bline")))
1306                                synfig::error("LayerParamConnect didn't like \"param\"");
1307                        if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
1308                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1309
1310                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1311                        {
1312                                group.cancel();
1313                                throw String(_("Unable to create Region layer"));
1314                                return;
1315                        }
1316                }
1317
1318                // only link the region's origin parameter if the option is selected and we're creating more than one layer
1319                if (get_layer_link_origins_flag() && layers_to_create > 1)
1320                {
1321                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1322                        assert(action);
1323
1324                        action->set_param("canvas",get_canvas());
1325                        action->set_param("canvas_interface",get_canvas_interface());
1326                        action->set_param("layer",layer);
1327                        if(!action->set_param("param",String("origin")))
1328                                synfig::error("LayerParamConnect didn't like \"param\"");
1329                        if(!action->set_param("value_node",ValueNode::Handle(value_node_origin)))
1330                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1331
1332                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1333                        {
1334                                group.cancel();
1335                                throw String(_("Unable to create Region layer"));
1336                                return;
1337                        }
1338                }
1339                else
1340                {
1341                        layer->set_param("origin",origin);
1342                        get_canvas_interface()->signal_layer_param_changed()(layer,"origin");
1343                }
1344        }
1345
1346        ///////////////////////////////////////////////////////////////////////////
1347        //   O U T L I N E
1348        ///////////////////////////////////////////////////////////////////////////
1349
1350        if (get_layer_outline_flag())
1351        {
1352                synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
1353
1354                egress_on_selection_change=false;
1355                Layer::Handle layer(get_canvas_interface()->add_layer_to("outline",canvas,depth));
1356                egress_on_selection_change=true;
1357                if (!layer)
1358                {
1359                        get_canvas_view()->get_ui_interface()->error(_("Unable to create layer"));
1360                        group.cancel();
1361                        return;
1362                }
1363                layer_selection.push_back(layer);
1364                layer->set_description(get_id()+_(" Outline"));
1365                get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
1366
1367                layer->set_param("amount",get_opacity());
1368                get_canvas_interface()->signal_layer_param_changed()(layer,"amount");
1369
1370                layer->set_param("blend_method",get_blend());
1371                get_canvas_interface()->signal_layer_param_changed()(layer,"blend_method");
1372
1373                layer->set_param("width",get_bline_width());
1374                get_canvas_interface()->signal_layer_param_changed()(layer,"width");
1375
1376                layer->set_param("feather",get_feather_size());
1377                get_canvas_interface()->signal_layer_param_changed()(layer,"feather");
1378
1379                layer->set_param("invert",get_invert());
1380                get_canvas_interface()->signal_layer_param_changed()(layer,"invert");
1381
1382                {
1383                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1384                        assert(action);
1385
1386                        action->set_param("canvas",get_canvas());
1387                        action->set_param("canvas_interface",get_canvas_interface());
1388                        action->set_param("layer",layer);
1389                        if(!action->set_param("param",String("bline")))
1390                                synfig::error("LayerParamConnect didn't like \"param\"");
1391                        if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
1392                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1393
1394                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1395                        {
1396                                group.cancel();
1397                                throw String(_("Unable to create Outline layer"));
1398                                return;
1399                        }
1400                }
1401
1402                // only link the outline's origin parameter if the option is selected and we're creating more than one layer
1403                if (get_layer_link_origins_flag() && layers_to_create > 1)
1404                {
1405                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1406                        assert(action);
1407
1408                        action->set_param("canvas",get_canvas());
1409                        action->set_param("canvas_interface",get_canvas_interface());
1410                        action->set_param("layer",layer);
1411                        if(!action->set_param("param",String("origin")))
1412                                synfig::error("LayerParamConnect didn't like \"param\"");
1413                        if(!action->set_param("value_node",ValueNode::Handle(value_node_origin)))
1414                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1415
1416                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1417                        {
1418                                group.cancel();
1419                                throw String(_("Unable to create Outline layer"));
1420                                return;
1421                        }
1422                }
1423                else
1424                {
1425                        layer->set_param("origin",origin);
1426                        get_canvas_interface()->signal_layer_param_changed()(layer,"origin");
1427                }
1428        }
1429
1430        ///////////////////////////////////////////////////////////////////////////
1431        //   A D V A N C E D   O U T L I N E
1432        ///////////////////////////////////////////////////////////////////////////
1433
1434        if (get_layer_advanced_outline_flag())
1435        {
1436                synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
1437
1438                egress_on_selection_change=false;
1439                Layer::Handle layer(get_canvas_interface()->add_layer_to("advanced_outline",canvas,depth));
1440                egress_on_selection_change=true;
1441                if (!layer)
1442                {
1443                        get_canvas_view()->get_ui_interface()->error(_("Unable to create layer"));
1444                        group.cancel();
1445                        return;
1446                }
1447                layer_selection.push_back(layer);
1448                layer->set_description(get_id()+_(" Advanced Outline"));
1449                get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
1450
1451                layer->set_param("amount",get_opacity());
1452                get_canvas_interface()->signal_layer_param_changed()(layer,"amount");
1453
1454                layer->set_param("blend_method",get_blend());
1455                get_canvas_interface()->signal_layer_param_changed()(layer,"blend_method");
1456
1457                layer->set_param("width",get_bline_width());
1458                get_canvas_interface()->signal_layer_param_changed()(layer,"width");
1459
1460                layer->set_param("feather",get_feather_size());
1461                get_canvas_interface()->signal_layer_param_changed()(layer,"feather");
1462
1463                layer->set_param("invert",get_invert());
1464                get_canvas_interface()->signal_layer_param_changed()(layer,"invert");
1465
1466                {
1467                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1468                        assert(action);
1469
1470                        action->set_param("canvas",get_canvas());
1471                        action->set_param("canvas_interface",get_canvas_interface());
1472                        action->set_param("layer",layer);
1473                        if(!action->set_param("param",String("bline")))
1474                                synfig::error("LayerParamConnect didn't like \"param\"");
1475                        if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
1476                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1477
1478                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1479                        {
1480                                group.cancel();
1481                                throw String(_("Unable to create Advanced Outline layer"));
1482                                return;
1483                        }
1484                }
1485
1486                // only link the advanced_outline's origin parameter if the option is selected and we're creating more than one layer
1487                if (get_layer_link_origins_flag() && layers_to_create > 1)
1488                {
1489                        synfigapp::Action::Handle action(synfigapp::Action::create("LayerParamConnect"));
1490                        assert(action);
1491
1492                        action->set_param("canvas",get_canvas());
1493                        action->set_param("canvas_interface",get_canvas_interface());
1494                        action->set_param("layer",layer);
1495                        if(!action->set_param("param",String("origin")))
1496                                synfig::error("LayerParamConnect didn't like \"param\"");
1497                        if(!action->set_param("value_node",ValueNode::Handle(value_node_origin)))
1498                                synfig::error("LayerParamConnect didn't like \"value_node\"");
1499
1500                        if(!get_canvas_interface()->get_instance()->perform_action(action))
1501                        {
1502                                group.cancel();
1503                                throw String(_("Unable to create Advanced Outline layer"));
1504                                return;
1505                        }
1506                }
1507                else
1508                {
1509                        layer->set_param("origin",origin);
1510                        get_canvas_interface()->signal_layer_param_changed()(layer,"origin");
1511                }
1512        }
1513        egress_on_selection_change=false;
1514        get_canvas_interface()->get_selection_manager()->clear_selected_layers();
1515        get_canvas_interface()->get_selection_manager()->set_selected_layers(layer_selection);
1516        egress_on_selection_change=true;
1517
1518        reset();
1519        increment_id();
1520}
1521
1522Smach::event_result
1523StateStar_Context::event_mouse_click_handler(const Smach::event& x)
1524{
1525        const EventMouse& event(*reinterpret_cast<const EventMouse*>(&x));
1526
1527        if(event.key==EVENT_WORKAREA_MOUSE_BUTTON_DOWN && event.button==BUTTON_LEFT)
1528        {
1529                point_holder=get_work_area()->snap_point_to_grid(event.pos);
1530                etl::handle<Duck> duck=new Duck();
1531                duck->set_point(point_holder);
1532                duck->set_name("p1");
1533                duck->set_type(Duck::TYPE_POSITION);
1534                duck->set_editable(false);
1535                get_work_area()->add_duck(duck);
1536
1537                point2_duck=new Duck();
1538                point2_duck->set_point(Vector(0,0));
1539                point2_duck->set_name("radius");
1540                point2_duck->set_origin(duck);
1541                point2_duck->set_radius(true);
1542                point2_duck->set_scalar(-1);
1543                point2_duck->set_type(Duck::TYPE_RADIUS);
1544                point2_duck->set_hover(true);
1545                get_work_area()->add_duck(point2_duck);
1546
1547                return Smach::RESULT_ACCEPT;
1548        }
1549
1550        if(event.key==EVENT_WORKAREA_MOUSE_BUTTON_DRAG && event.button==BUTTON_LEFT)
1551        {
1552                if (!point2_duck) return Smach::RESULT_OK;
1553                point2_duck->set_point(point_holder-get_work_area()->snap_point_to_grid(event.pos));
1554                get_work_area()->queue_draw();
1555                return Smach::RESULT_ACCEPT;
1556        }
1557
1558        if(event.key==EVENT_WORKAREA_MOUSE_BUTTON_UP && event.button==BUTTON_LEFT)
1559        {
1560                Point point(get_work_area()->snap_point_to_grid(event.pos));
1561
1562                if (App::restrict_radius_ducks)
1563                {
1564                        if ((point[0] - point_holder[0]) < 0) point[0] = point_holder[0];
1565                        if ((point[1] - point_holder[1]) < 0) point[1] = point_holder[1];
1566                }
1567
1568                make_star(point_holder, point);
1569                get_work_area()->clear_ducks();
1570                return Smach::RESULT_ACCEPT;
1571        }
1572
1573        return Smach::RESULT_OK;
1574}
1575
1576
1577void
1578StateStar_Context::refresh_ducks()
1579{
1580        get_work_area()->clear_ducks();
1581        get_work_area()->queue_draw();
1582}
1583
1584void
1585StateStar_Context::toggle_layer_creation()
1586{
1587        // don't allow none layer creation
1588  if (get_layer_star_flag() +
1589     get_layer_region_flag() +
1590     get_layer_outline_flag() +
1591     get_layer_advanced_outline_flag() +
1592     get_layer_curve_gradient_flag() +
1593     get_layer_plant_flag() == 0)
1594  {
1595    if(layer_star_flag) set_layer_star_flag(true);
1596    else if(layer_region_flag) set_layer_region_flag(true);
1597    else if(layer_outline_flag) set_layer_outline_flag(true);
1598    else if(layer_advanced_outline_flag) set_layer_advanced_outline_flag(true);
1599    else if(layer_curve_gradient_flag) set_layer_curve_gradient_flag(true);
1600    else if(layer_plant_flag) set_layer_plant_flag(true);
1601  }
1602
1603        // brush size
1604        if (get_layer_outline_flag() ||
1605                get_layer_advanced_outline_flag() ||
1606                get_layer_curve_gradient_flag())
1607        {
1608                bline_width_label.set_sensitive(true);
1609                bline_width_dist.set_sensitive(true);
1610        }
1611        else
1612        {
1613                bline_width_label.set_sensitive(false);
1614                bline_width_dist.set_sensitive(false);
1615        }
1616
1617        // inner/outer width and tangent
1618        if (get_layer_region_flag() ||
1619                get_layer_outline_flag() ||
1620                get_layer_advanced_outline_flag() ||
1621                get_layer_plant_flag() ||
1622                get_layer_curve_gradient_flag())
1623        {
1624                inner_width_label.set_sensitive(true);
1625                inner_width_spin.set_sensitive(true);
1626                inner_tangent_label.set_sensitive(true);
1627                inner_tangent_spin.set_sensitive(true);
1628                outer_width_label.set_sensitive(true);
1629                outer_width_spin.set_sensitive(true);
1630                outer_tangent_label.set_sensitive(true);
1631                outer_tangent_spin.set_sensitive(true);
1632        }
1633        else
1634        {
1635                inner_width_label.set_sensitive(false);
1636                inner_width_spin.set_sensitive(false);
1637                inner_tangent_label.set_sensitive(false);
1638                inner_tangent_spin.set_sensitive(false);
1639                outer_width_label.set_sensitive(false);
1640                outer_width_spin.set_sensitive(false);
1641                outer_tangent_label.set_sensitive(false);
1642                outer_tangent_spin.set_sensitive(false);
1643        }
1644
1645        // invert
1646        if (get_layer_star_flag() ||
1647                get_layer_region_flag() ||
1648                get_layer_outline_flag() ||
1649                get_layer_advanced_outline_flag())
1650        {
1651                invert_box.set_sensitive(true);
1652        }
1653        else
1654                invert_box.set_sensitive(false);
1655
1656        // feather size
1657        if (get_layer_star_flag() ||
1658                get_layer_region_flag() ||
1659                get_layer_outline_flag() ||
1660                get_layer_advanced_outline_flag())
1661        {
1662                feather_label.set_sensitive(true);
1663                feather_dist.set_sensitive(true);
1664        }
1665        else
1666        {
1667                feather_label.set_sensitive(false);
1668                feather_dist.set_sensitive(false);
1669        }
1670
1671        // orignis at center
1672        if (get_layer_region_flag() ||
1673                get_layer_outline_flag() ||
1674                get_layer_advanced_outline_flag() ||
1675                get_layer_plant_flag() ||
1676                get_layer_curve_gradient_flag())
1677        {
1678                origins_at_center_box.set_sensitive(true);
1679        }
1680        else
1681                origins_at_center_box.set_sensitive(false);
1682
1683        // link origins
1684        if (get_layer_region_flag() +
1685                get_layer_outline_flag() +
1686                get_layer_advanced_outline_flag() +
1687                get_layer_plant_flag() +
1688                get_layer_curve_gradient_flag() +
1689                get_layer_star_flag() >= 2)
1690        {
1691                link_origins_box.set_sensitive(true);
1692        }
1693        else link_origins_box.set_sensitive(false);
1694
1695  // update layer flags
1696  layer_star_flag = get_layer_star_flag();
1697  layer_region_flag = get_layer_region_flag();
1698  layer_outline_flag = get_layer_outline_flag();
1699  layer_advanced_outline_flag = get_layer_advanced_outline_flag();
1700  layer_curve_gradient_flag = get_layer_curve_gradient_flag();
1701  layer_plant_flag = get_layer_plant_flag();
1702}
Note: See TracBrowser for help on using the repository browser.