#
# Script to generate API documentation and send it to sf.net
#
-# Copyright 2009 Konstantin Dmitriev
+# Copyright 2009-2010 Konstantin Dmitriev
+# Copyright 2010 Carlos López
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of
# the License, or (at your option) any later version.
+#
+# This script has been redesigned to be used in a cron work.
+# Adapt the following macros to the proper directories values.
-export HTMLDIR=$HOME/synfig/api/html
-export SOURCEDIR=$HOME/synfig/api/source
+export HTMLDIR=$HOME/synfig/synfig-repository/api
+export SOURCEDIR=$HOME/synfig/synfig-repository/code/synfig
set -e
if [ ! -d $SOURCEDIR ]; then
mkdir -p `dirname $SOURCEDIR`
cd `dirname $SOURCEDIR`
- git clone git://synfig.git.sourceforge.net/gitroot/synfig `basename $SOURCEDIR`
+ git clone --depth 1 git://synfig.git.sourceforge.net/gitroot/synfig/synfig `basename $SOURCEDIR`
fi
-getversion(){
- VERSION=`cat configure| egrep PACKAGE_VERSION=\'`
- VERSION=${VERSION#*\'}
- VERSION=${VERSION%\'}
-}
-
mkdir -p $HTMLDIR
cd $SOURCEDIR
#generating api to htmldir
for module in ETL synfig-core synfig-studio; do
-cd $module/trunk
+cd $module
echo "Generating API for $module..."
-autoreconf --install --force || ( sed -i 's/^AC_CONFIG_SUBDIRS/# AC_CONFIG_SUBDIRS/' configure.ac && autoreconf --install --force )
-getversion
+case $module in
+ ETL)
+ MODULETITLE='Extended Template Library'
+ ;;
+ synfig-core)
+ MODULETITLE='Synfig Core'
+ ;;
+ synfig-studio)
+ MODULETITLE='Synfig Studio'
+ ;;
+esac
+ VERSION=`cat configure.ac |egrep "AC_INIT\(\[$MODULETITLE\],"| sed "s|.*$MODULETITLE\],\[||" | sed "s|\],\[.*||"`
+ VERSION=${VERSION#*\'}
+ VERSION=${VERSION%\'}
cp -f doxygen.cfg.in doxygen.cfg
sed -i "s/@VERSION@/$VERSION/" doxygen.cfg
sed -i "s/@PACKAGE@/$module/" doxygen.cfg
doxygen doxygen.cfg
rm -rf $HTMLDIR/$module
mv doc/html $HTMLDIR/$module
-cp $SOURCEDIR/$module/trunk/doxygen.cfg $HTMLDIR/$module
-cd ../..
+cp $SOURCEDIR/$module/doxygen.cfg $HTMLDIR/$module
+cd ..
done
#index.html
<body>
<h1>ETL, synfig, synfigstudio API docs</h1>
<ul>
-<li><a href="ETL/">ETL</a></li>
-<li><a href="synfig/">synfig</a></li>
-<li><a href="synfigstudio/">synfigstudio</a></li>
+<li><a href="ETL/index.html">ETL</a></li>
+<li><a href="synfig-core/index.html">synfig-core</a></li>
+<li><a href="synfig-studio/index.html">synfig-studio</a></li>
</ul>
<p>Generated on: $DATE.</p>
</body></html>
EOF
-#beep (because we asking password)
-echo -e "\a"; sleep 0.2; echo -e "\a"; sleep 0.2; echo -e "\a"
-
-echo -n "Enter your sf.net username: "
-read USERNAME
-
-#push to sf.net
-rsync -avP -e ssh $HTMLDIR/ $USERNAME,synfig@web.sourceforge.net:htdocs/api/
-
return canvas_interface()->change_value(synfigapp::ValueDesc(layer,param_name),value);
}
-bool
-CanvasView::on_duck_changed(const synfig::Point &value,const synfigapp::ValueDesc& value_desc)
-{
- if (ValueNode_BLineCalcWidth::Handle bline_width = ValueNode_BLineCalcWidth::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- Real old_width((*bline_width)(get_time()).get(Real()));
- Real new_width(value.mag());
- int scale_index(bline_width->get_link_index_from_name("scale"));
- Real scale((*(bline_width->get_link(scale_index)))(get_time()).get(Real()));
- return canvas_interface()->change_value(synfigapp::ValueDesc(bline_width,scale_index), new_width * scale / old_width);
- }
-
- if (ValueNode_BLineCalcVertex::Handle bline_vertex = ValueNode_BLineCalcVertex::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- ValueNode_BLine::Handle bline = ValueNode_BLine::Handle::cast_dynamic(bline_vertex->get_link("bline"));
- Real radius = 0.0;
- if (((*(bline_vertex->get_link("loop")))(get_time()).get(bool()))){
- Real amount_old((*(bline_vertex->get_link("amount")))(get_time()).get(Real()));
- Real amount_new = synfig::find_closest_point((*bline)(get_time()), value, radius, bline->get_loop());
- Real difference = fmod( fmod(amount_new - amount_old, 1.0) + 1.0 , 1.0);
- //fmod is called twice to avoid negative values
- if (difference > 0.5) difference=difference-1.0;
- return canvas_interface()->change_value(synfigapp::ValueDesc(bline_vertex,bline_vertex->get_link_index_from_name("amount")), amount_old+difference);
-
- } else {
- Real amount = synfig::find_closest_point((*bline)(get_time()), value, radius, bline->get_loop());
- return canvas_interface()->change_value(synfigapp::ValueDesc(bline_vertex,bline_vertex->get_link_index_from_name("amount")), amount);
- }
- }
-
- if (ValueNode_BLineCalcTangent::Handle bline_tangent = ValueNode_BLineCalcTangent::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- switch(value_desc.get_value_type())
- {
- case ValueBase::TYPE_REAL:
- {
- Real old_length = (*bline_tangent)(get_time()).get(Real());
- Real new_length = value.mag();
- int scale_index(bline_tangent->get_link_index_from_name("scale"));
- int fixed_length_index(bline_tangent->get_link_index_from_name("fixed_length"));
- Real scale((*(bline_tangent->get_link(scale_index)))(get_time()).get(Real()));
- bool fixed_length((*(bline_tangent->get_link(fixed_length_index)))(get_time()).get(bool()));
- if (fixed_length)
- return canvas_interface()->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length);
- if (old_length == 0)
- return true;
- return canvas_interface()->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length * scale / old_length);
- }
-
- case ValueBase::TYPE_ANGLE:
- assert(0); // doesn't happen?
- break;
-
- case ValueBase::TYPE_VECTOR:
- {
- Vector old_tangent = (*bline_tangent)(get_time()).get(Vector());
- Angle old_angle = old_tangent.angle();
- Real old_length = old_tangent.mag();
- Angle new_angle = value.angle();
- Real new_length = value.mag();
- int offset_index(bline_tangent->get_link_index_from_name("offset"));
- int scale_index(bline_tangent->get_link_index_from_name("scale"));
- int fixed_length_index(bline_tangent->get_link_index_from_name("fixed_length"));
- Angle old_offset((*(bline_tangent->get_link(offset_index)))(get_time()).get(Angle()));
- Real scale((*(bline_tangent->get_link(scale_index)))(get_time()).get(Real()));
- bool fixed_length((*(bline_tangent->get_link(fixed_length_index)))(get_time()).get(bool()));
- if (fixed_length)
- {
- if (!(canvas_interface()->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length)))
- return false;
- }
- else if (old_length != 0 && !(canvas_interface()->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length * scale / old_length)))
- return false;
- return canvas_interface()->change_value(synfigapp::ValueDesc(bline_tangent,offset_index), old_offset + new_angle - old_angle);
- }
- default:
- break;
- }
- }
-
- if (ValueNode_Scale::Handle scale_value_node = ValueNode_Scale::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- int link_index(scale_value_node->get_link_index_from_name("link"));
- if(scale_value_node->is_invertible(get_time()))
- return canvas_interface()->change_value(
- synfigapp::ValueDesc(scale_value_node,link_index),
- scale_value_node->get_inverse(get_time(), value)
- );
- else
- return false;
- }
-
- if (ValueNode_Range::Handle range_value_node = ValueNode_Range::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- int link_index(range_value_node->get_link_index_from_name("link"));
- return canvas_interface()->change_value(
- synfigapp::ValueDesc(range_value_node,link_index),
- range_value_node->get_inverse(get_time(), value)
- );
- }
-
- switch(value_desc.get_value_type())
- {
- case ValueBase::TYPE_REAL:
- return canvas_interface()->change_value(value_desc,value.mag());
- case ValueBase::TYPE_ANGLE:
- return canvas_interface()->change_value(value_desc,Angle::tan(value[1],value[0]));
- default:
- return canvas_interface()->change_value(value_desc,value);
- }
-}
-
-bool
-CanvasView::on_duck_angle_changed(const synfig::Angle &rotation,const synfigapp::ValueDesc& value_desc)
-{
- if (ValueNode_BLineCalcTangent::Handle bline_tangent = ValueNode_BLineCalcTangent::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- int offset_index(bline_tangent->get_link_index_from_name("offset"));
- Angle old_offset((*(bline_tangent->get_link(offset_index)))(get_time()).get(Angle()));
- return canvas_interface()->change_value(synfigapp::ValueDesc(bline_tangent,offset_index), old_offset + rotation);
- }
-
- if (ValueNode_Scale::Handle scale_value_node = ValueNode_Scale::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- int link_index(scale_value_node->get_link_index_from_name("link"));
- if(scale_value_node->is_invertible(get_time()))
- return canvas_interface()->change_value(
- synfigapp::ValueDesc(scale_value_node,link_index),
- scale_value_node->get_inverse(get_time(), rotation)
- );
- else
- return false;
-
- }
- if (ValueNode_Range::Handle range_value_node = ValueNode_Range::Handle::cast_dynamic(value_desc.get_value_node()))
- {
- int link_index(range_value_node->get_link_index_from_name("link"));
- return canvas_interface()->change_value(
- synfigapp::ValueDesc(range_value_node,link_index),
- range_value_node->get_inverse(get_time(), rotation)
- );
- }
- // \todo will this really always be the case?
- assert(value_desc.get_value_type() == ValueBase::TYPE_ANGLE);
- return canvas_interface()->change_value(value_desc, value_desc.get_value(get_time()).get(Angle()) + rotation);
-}
-
void
CanvasView::selected_layer_color_set(synfig::Color color)
{
void on_audio_file_notify();
void on_audio_offset_notify();
- bool on_duck_changed(const synfig::Point &value,const synfigapp::ValueDesc& value_desc);
- bool on_duck_angle_changed(const synfig::Angle &rotation,const synfigapp::ValueDesc& value_desc);
-
void on_layer_toggle(synfig::Layer::Handle);
void on_edited_value(synfigapp::ValueDesc,synfig::ValueBase);
const synfig::TransformStack& get_transform_stack()const { return transform_stack_; }
- //! \writeme
+ //! Sets the type of duck
void set_type(Type x) { type_=x; }
- //! \writeme
+ //! Gets the type of duck
Type get_type()const { return type_; }
//! Sets the scalar multiplier for the duck with respect to the origin
//! Returns the location of the duck
synfig::Point get_point()const { return shared_point?*shared_point:point; }
+ //! Returns the rotations of the duck
+ /*! For angle and tangent ducks, rotations are used instead of the location
+ * so that the duck can me rotated more than 180 degrees
+ */
synfig::Angle get_rotations()const { return rotations; };
+
+ //! Sets the rotations of the duck
void set_rotations(const synfig::Angle &x) { rotations=x; };
synfig::Point get_trans_point()const;
#include "duckmatic.h"
#include <synfigapp/value_desc.h>
+#include <synfigapp/canvasinterface.h>
#include <synfig/general.h>
#include <synfig/paramdesc.h>
#include <synfig/valuenode_timedswap.h>
#include <synfig/valuenode_animated.h>
#include <synfig/valuenode_composite.h>
+#include <synfig/valuenode_range.h>
#include <synfig/valuenode_scale.h>
#include <synfig/valuenode_bline.h>
#include <synfig/valuenode_blinecalctangent.h>
/* === E N T R Y P O I N T ================================================= */
-Duckmatic::Duckmatic():
+Duckmatic::Duckmatic(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface):
+ canvas_interface(canvas_interface),
type_mask(Duck::TYPE_ALL-Duck::TYPE_WIDTH),
grid_snap(false),
guide_snap(false),
stroke_list_=persistent_stroke_list_;
}
-//! Returns \a true if the given duck is currently selected
+
bool
Duckmatic::duck_is_selected(const etl::handle<Duck> &duck)const
{
last_translate_=vect;
}
+
+void
+Duckmatic::signal_user_click_selected_ducks(int button)
+{
+ const DuckList ducks(get_selected_ducks());
+ DuckList::const_iterator iter;
+
+ for(iter=ducks.begin();iter!=ducks.end();++iter)
+ {
+ (*iter)->signal_user_click(button)();
+ }
+}
+
+
void
Duckmatic::signal_edited_selected_ducks()
{
selected_ducks=old_set;
}
-void
-Duckmatic::signal_user_click_selected_ducks(int button)
+
+bool
+Duckmatic::on_duck_changed(const synfig::Point &value,const synfigapp::ValueDesc& value_desc)
{
- const DuckList ducks(get_selected_ducks());
- DuckList::const_iterator iter;
+ if (ValueNode_BLineCalcWidth::Handle bline_width = ValueNode_BLineCalcWidth::Handle::cast_dynamic(value_desc.get_value_node()))
+ {
+ Real old_width((*bline_width)(get_time()).get(Real()));
+ Real new_width(value.mag());
+ int scale_index(bline_width->get_link_index_from_name("scale"));
+ Real scale((*(bline_width->get_link(scale_index)))(get_time()).get(Real()));
+ return canvas_interface->change_value(synfigapp::ValueDesc(bline_width,scale_index), new_width * scale / old_width);
+ }
- for(iter=ducks.begin();iter!=ducks.end();++iter)
+ if (ValueNode_BLineCalcVertex::Handle bline_vertex = ValueNode_BLineCalcVertex::Handle::cast_dynamic(value_desc.get_value_node()))
{
- (*iter)->signal_user_click(button)();
+ ValueNode_BLine::Handle bline = ValueNode_BLine::Handle::cast_dynamic(bline_vertex->get_link("bline"));
+ Real radius = 0.0;
+ if (((*(bline_vertex->get_link("loop")))(get_time()).get(bool()))){
+ Real amount_old((*(bline_vertex->get_link("amount")))(get_time()).get(Real()));
+ Real amount_new = synfig::find_closest_point((*bline)(get_time()), value, radius, bline->get_loop());
+ Real difference = fmod( fmod(amount_new - amount_old, 1.0) + 1.0 , 1.0);
+ //fmod is called twice to avoid negative values
+ if (difference > 0.5) difference=difference-1.0;
+ return canvas_interface->change_value(synfigapp::ValueDesc(bline_vertex,bline_vertex->get_link_index_from_name("amount")), amount_old+difference);
+
+ } else {
+ Real amount = synfig::find_closest_point((*bline)(get_time()), value, radius, bline->get_loop());
+ return canvas_interface->change_value(synfigapp::ValueDesc(bline_vertex,bline_vertex->get_link_index_from_name("amount")), amount);
+ }
+ }
+
+ if (ValueNode_BLineCalcTangent::Handle bline_tangent = ValueNode_BLineCalcTangent::Handle::cast_dynamic(value_desc.get_value_node()))
+ {
+ switch(value_desc.get_value_type())
+ {
+ case ValueBase::TYPE_REAL:
+ {
+ Real old_length = (*bline_tangent)(get_time()).get(Real());
+ Real new_length = value.mag();
+ int scale_index(bline_tangent->get_link_index_from_name("scale"));
+ int fixed_length_index(bline_tangent->get_link_index_from_name("fixed_length"));
+ Real scale((*(bline_tangent->get_link(scale_index)))(get_time()).get(Real()));
+ bool fixed_length((*(bline_tangent->get_link(fixed_length_index)))(get_time()).get(bool()));
+ if (fixed_length)
+ return canvas_interface->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length);
+ if (old_length == 0)
+ return true;
+ return canvas_interface->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length * scale / old_length);
+ }
+
+ case ValueBase::TYPE_ANGLE:
+ assert(0); // doesn't happen?
+ break;
+
+ case ValueBase::TYPE_VECTOR:
+ {
+ Vector old_tangent = (*bline_tangent)(get_time()).get(Vector());
+ Angle old_angle = old_tangent.angle();
+ Real old_length = old_tangent.mag();
+ Angle new_angle = value.angle();
+ Real new_length = value.mag();
+ int offset_index(bline_tangent->get_link_index_from_name("offset"));
+ int scale_index(bline_tangent->get_link_index_from_name("scale"));
+ int fixed_length_index(bline_tangent->get_link_index_from_name("fixed_length"));
+ Angle old_offset((*(bline_tangent->get_link(offset_index)))(get_time()).get(Angle()));
+ Real scale((*(bline_tangent->get_link(scale_index)))(get_time()).get(Real()));
+ bool fixed_length((*(bline_tangent->get_link(fixed_length_index)))(get_time()).get(bool()));
+ if (fixed_length)
+ {
+ if (!(canvas_interface->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length)))
+ return false;
+ }
+ else if (old_length != 0 && !(canvas_interface->change_value(synfigapp::ValueDesc(bline_tangent,scale_index), new_length * scale / old_length)))
+ return false;
+ return canvas_interface->change_value(synfigapp::ValueDesc(bline_tangent,offset_index), old_offset + new_angle - old_angle);
+ }
+ default:
+ break;
+ }
+ }
+
+ if (ValueNode_Scale::Handle scale_value_node = ValueNode_Scale::Handle::cast_dynamic(value_desc.get_value_node()))
+ {
+ int link_index(scale_value_node->get_link_index_from_name("link"));
+ if(scale_value_node->is_invertible(get_time()))
+ return canvas_interface->change_value(
+ synfigapp::ValueDesc(scale_value_node,link_index),
+ scale_value_node->get_inverse(get_time(), value)
+ );
+ else
+ return false;
+ }
+
+ if (ValueNode_Range::Handle range_value_node = ValueNode_Range::Handle::cast_dynamic(value_desc.get_value_node()))
+ {
+ int link_index(range_value_node->get_link_index_from_name("link"));
+ return canvas_interface->change_value(
+ synfigapp::ValueDesc(range_value_node,link_index),
+ range_value_node->get_inverse(get_time(), value)
+ );
+ }
+
+ switch(value_desc.get_value_type())
+ {
+ case ValueBase::TYPE_REAL:
+ return canvas_interface->change_value(value_desc,value.mag());
+ case ValueBase::TYPE_ANGLE:
+ return canvas_interface->change_value(value_desc,Angle::tan(value[1],value[0]));
+ default:
+ return canvas_interface->change_value(value_desc,value);
+ }
+}
+
+bool
+Duckmatic::on_duck_angle_changed(const synfig::Angle &rotation,const synfigapp::ValueDesc& value_desc)
+{
+ if (ValueNode_BLineCalcTangent::Handle bline_tangent = ValueNode_BLineCalcTangent::Handle::cast_dynamic(value_desc.get_value_node()))
+ {
+ int offset_index(bline_tangent->get_link_index_from_name("offset"));
+ Angle old_offset((*(bline_tangent->get_link(offset_index)))(get_time()).get(Angle()));
+ return canvas_interface->change_value(synfigapp::ValueDesc(bline_tangent,offset_index), old_offset + rotation);
+ }
+
+ if (ValueNode_Scale::Handle scale_value_node = ValueNode_Scale::Handle::cast_dynamic(value_desc.get_value_node()))
+ {
+ int link_index(scale_value_node->get_link_index_from_name("link"));
+ if(scale_value_node->is_invertible(get_time()))
+ return canvas_interface->change_value(
+ synfigapp::ValueDesc(scale_value_node,link_index),
+ scale_value_node->get_inverse(get_time(), rotation)
+ );
+ else
+ return false;
+
+ }
+ if (ValueNode_Range::Handle range_value_node = ValueNode_Range::Handle::cast_dynamic(value_desc.get_value_node()))
+ {
+ int link_index(range_value_node->get_link_index_from_name("link"));
+ return canvas_interface->change_value(
+ synfigapp::ValueDesc(range_value_node,link_index),
+ range_value_node->get_inverse(get_time(), rotation)
+ );
}
+ // \todo will this really always be the case?
+ assert(value_desc.get_value_type() == ValueBase::TYPE_ANGLE);
+ return canvas_interface->change_value(value_desc, value_desc.get_value(get_time()).get(Angle()) + rotation);
}
void
duck->signal_edited().connect(
sigc::bind(
sigc::mem_fun(
- *canvas_view,
- &studio::CanvasView::on_duck_changed),
+ *this,
+ &studio::Duckmatic::on_duck_changed),
value_desc));
duck->set_value_desc(value_desc);
duck->signal_edited_angle().connect(
sigc::bind(
sigc::mem_fun(
- *canvas_view,
- &studio::CanvasView::on_duck_angle_changed),
+ *this,
+ &studio::Duckmatic::on_duck_angle_changed),
value_desc));
duck->set_value_desc(value_desc);
duck->signal_edited().connect(
sigc::bind(
sigc::mem_fun(
- *canvas_view,
- &studio::CanvasView::on_duck_changed),
+ *this,
+ &studio::Duckmatic::on_duck_changed),
value_desc));
duck->set_value_desc(value_desc);
/* === C L A S S E S & S T R U C T S ======================================= */
-namespace synfigapp { class ValueDesc; }
+namespace synfigapp { class ValueDesc; class CanvasInterface; }
namespace synfig { class ParamDesc; }
namespace studio
** the work area that the user may want to interact with.
** This includes ducks, beziers, and strokes
**
-** \note At some point I'll probably rename this class to "DuckOMatic".
*/
class Duckmatic
{
private:
+ etl::loose_handle<synfigapp::CanvasInterface> canvas_interface;
+
Type type_mask;
DuckMap duck_map;
public:
- Duckmatic();
+ Duckmatic(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface);
virtual ~Duckmatic();
sigc::signal<void>& signal_duck_selection_changed() { return signal_duck_selection_changed_; }
void unselect_duck(const etl::handle<Duck> &duck);
+ //! Begin dragging ducks
+ /*! \param offset Canvas coordinates of the mouse when the drag began */
void start_duck_drag(const synfig::Vector& offset);
+
+ //! Continue dragging the selected ducks
+ /*! The overall vector of the drag is vector-offset
+ * (where offset was given in start_duck_drag)
+ * \param vector Canvas coordinates of the mouse at this moment */
void translate_selected_ducks(const synfig::Vector& vector);
+
+ //! Update the coordinates of tangents and linked-to-bline ducks
void update_ducks();
- bool end_duck_drag();
- void signal_edited_selected_ducks();
+ //! Ends the duck drag
+ bool end_duck_drag();
+ //! Signals to each selected duck that it has been clicked
void signal_user_click_selected_ducks(int button);
+ //! Calls all of the ducks' edited signals
+ /*! Updates corresponding valuenodes after a drag */
+ void signal_edited_selected_ducks();
+
+ bool on_duck_changed(const synfig::Point &value,const synfigapp::ValueDesc& value_desc);
+ bool on_duck_angle_changed(const synfig::Angle &rotation,const synfigapp::ValueDesc& value_desc);
etl::handle<Duck> find_similar_duck(etl::handle<Duck> duck);
etl::handle<Duck> add_similar_duck(etl::handle<Duck> duck);
bool add_to_ducks(const synfigapp::ValueDesc& value_desc,etl::handle<CanvasView> canvas_view, const synfig::TransformStack& transform_stack_, synfig::ParamDesc *param_desc=0, int multiple=0);
- //! \writeme
+ //! Set the type mask, which determines what types of ducks are shown
void set_type_mask(Type x) { type_mask=x; }
- //! \writeme
+ //! Get the type mask, which determines what types of ducks are shown
Type get_type_mask()const { return type_mask; }
void select_all_ducks();
synfig::KeyframeList &keyframe_list(canvas_interface()->get_canvas()->keyframe_list());
if(keyframe_list.empty())
- throw std::runtime_error(_("There are no keyframes n this canvas"));
+ throw std::runtime_error(_("There are no keyframes in this canvas"));
iter->index=0;
const LayerTreeStore::Model model;
{ // --- O N / O F F ----------------------------------------------------
- //int index;
- //index=get_layer_tree_view().append_column_editable(_(" "),layer_model.active);
- //Gtk::TreeView::Column* column = get_layer_tree_view().get_column(index-1);
-
Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_(" ")) );
- // Set up the icon cell-renderer
+ // Set up the on/off cell-renderer
Gtk::CellRendererToggle* cellrenderer = Gtk::manage( new Gtk::CellRendererToggle() );
cellrenderer->signal_toggled().connect(sigc::mem_fun(*this, &studio::LayerTree::on_layer_toggle));
-
column->pack_start(*cellrenderer,false);
column->add_attribute(cellrenderer->property_active(), layer_model.active);
get_layer_tree_view().append_column(*column);
{ // --- I C O N --------------------------------------------------------
int index;
- index=get_layer_tree_view().append_column(_("Z"),layer_model.icon);
+ // Set up the icon cell-renderer
+ index=get_layer_tree_view().append_column(_("Icon"),layer_model.icon);
Gtk::TreeView::Column* column = get_layer_tree_view().get_column(index-1);
get_layer_tree_view().set_expander_column(*column);
-
- column->set_sort_column(layer_model.z_depth);
- //column->set_reorderable();
- //column->set_resizable();
- //column->set_clickable();
-
- //Gtk::CellRendererPixbuf* icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
- //column->pack_start(*icon_cellrenderer,false);
- //column->add_attribute(icon_cellrenderer->property_pixbuf(), layer_model.icon);
}
- //get_layer_tree_view().append_column(_("Z"),layer_model.z_depth);
{ // --- N A M E --------------------------------------------------------
Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Name")) );
- // Set up the icon cell-renderer
+ // Set up the Layer label cell-renderer
Gtk::CellRendererText* cellrenderer = Gtk::manage( new Gtk::CellRendererText() );
column->pack_start(*cellrenderer,false);
column->add_attribute(cellrenderer->property_text(), layer_model.label);
cellrenderer->property_editable()=true;
column->set_reorderable();
- // column->set_resizable();
+ column->set_resizable();
column->set_clickable(true);
column->set_sort_column(layer_model.label);
get_layer_tree_view().append_column(*column);
-
- // int index;
-// index=get_layer_tree_view().append_column_editable(_("Layer"),layer_model.label);
- //Gtk::TreeView::Column* column = get_layer_tree_view().get_column(index-1);
-
- //get_layer_tree_view().set_expander_column(*column);
-
- //Gtk::CellRendererPixbuf* icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
- //column->pack_start(*icon_cellrenderer,false);
- //column->add_attribute(icon_cellrenderer->property_pixbuf(), layer_model.icon);
}
{ // --- Z D E P T H ----------------------------------------------------
int index;
- index=get_layer_tree_view().append_column(_("Z"),layer_model.z_depth);
- column_z_depth=get_layer_tree_view().get_column(index-1);
+ index=get_layer_tree_view().append_column(_("Z Depth"),layer_model.z_depth);
+ // Set up the Z-Depth label cell-renderer
+ column_z_depth=get_layer_tree_view().get_column(index-1);
column_z_depth->set_reorderable();
column_z_depth->set_resizable();
column_z_depth->set_clickable();
WorkArea::WorkArea(etl::loose_handle<synfigapp::CanvasInterface> canvas_interface):
Gtk::Table(3, 3, false), /* 3 columns by 3 rows*/
+ Duckmatic(canvas_interface),
canvas_interface(canvas_interface),
canvas(canvas_interface->get_canvas()),
scrollx_adjustment(0,-4,4,0.01,0.1),
projects / synfig.git / commitdiff