X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-studio%2Ftags%2Fstable%2Fsrc%2Fgtkmm%2Fduck.h;h=8ac7dbb3f77988475a886b644a9ed764543a7010;hb=47fce282611fbba1044921d22ca887f9b53ad91a;hp=a8fb4fad306d9b1c1a681f2dee4af360e851bf60;hpb=7c6d5426922cb3cda793f688dcd4d534b02765c8;p=synfig.git diff --git a/synfig-studio/tags/stable/src/gtkmm/duck.h b/synfig-studio/tags/stable/src/gtkmm/duck.h index a8fb4fa..8ac7dbb 100644 --- a/synfig-studio/tags/stable/src/gtkmm/duck.h +++ b/synfig-studio/tags/stable/src/gtkmm/duck.h @@ -1,28 +1,30 @@ -/* === S I N F G =========================================================== */ +/* === S Y N F I G ========================================================= */ /*! \file duck.h ** \brief Template Header ** -** $Id: duck.h,v 1.1.1.1 2005/01/07 03:34:36 darco Exp $ +** $Id$ ** ** \legal -** Copyright (c) 2002 Robert B. Quattlebaum Jr. +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2007, 2008 Chris Moore ** -** This software and associated documentation -** are CONFIDENTIAL and PROPRIETARY property of -** the above-mentioned copyright holder. +** This package 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. ** -** You may not copy, print, publish, or in any -** other way distribute this software without -** a prior written agreement with -** the copyright holder. +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. ** \endlegal */ /* ========================================================================= */ /* === S T A R T =========================================================== */ -#ifndef __SINFG_DUCKMATIC_DUCK_H -#define __SINFG_DUCKMATIC_DUCK_H +#ifndef __SYNFIG_DUCKMATIC_DUCK_H +#define __SYNFIG_DUCKMATIC_DUCK_H /* === H E A D E R S ======================================================= */ @@ -31,32 +33,39 @@ #include #include -#include -#include -#include +#include +#include +#include #include #include -#include +#include #include -#include -#include +#include +#include /* === M A C R O S ========================================================= */ -#define HASH_MAP_H -#define HASH_SET_H - #ifdef HASH_MAP_H #include HASH_MAP_H +#include FUNCTIONAL_H + #ifndef __STRING_HASH__ #define __STRING_HASH__ class StringHash { - __gnu_cxx::hash hasher_; +# ifdef FUNCTIONAL_HASH_ON_STRING + HASH_MAP_NAMESPACE::hash hasher_; +# else // FUNCTIONAL_HASH_ON_STRING + HASH_MAP_NAMESPACE::hash hasher_; +# endif // FUNCTIONAL_HASH_ON_STRING public: - size_t operator()(const sinfg::String& x)const + size_t operator()(const synfig::String& x)const { +# ifdef FUNCTIONAL_HASH_ON_STRING + return hasher_(x); +# else // FUNCTIONAL_HASH_ON_STRING return hasher_(x.c_str()); +# endif // FUNCTIONAL_HASH_ON_STRING } }; #endif @@ -72,23 +81,23 @@ public: namespace studio { class Duckmatic; - + /*! \class Duck ** \writeme */ class Duck : public etl::shared_object { friend class Duckmatic; - + public: enum Type { - TYPE_NONE = (0), - TYPE_POSITION = (1<<0), - TYPE_TANGENT = (1<<1), - TYPE_RADIUS = (1<<2), - TYPE_WIDTH = (1<<3), - TYPE_ANGLE = (1<<4), - TYPE_VERTEX = (1<<5), + TYPE_NONE = (0), // 0 + TYPE_POSITION = (1<<0), // 1 + TYPE_TANGENT = (1<<1), // 2 + TYPE_RADIUS = (1<<2), // 4 + TYPE_WIDTH = (1<<3), // 8 + TYPE_ANGLE = (1<<4), // 16 + TYPE_VERTEX = (1<<5), // 32 TYPE_ALL = (~0), @@ -97,52 +106,57 @@ public: typedef etl::handle Handle; typedef etl::loose_handle LooseHandle; - + private: - sigc::signal signal_edited_; + sigc::signal signal_edited_; + sigc::signal signal_edited_angle_; sigc::signal signal_user_click_[5]; - + Type type_; - sinfg::Point point; + synfig::Point point; + synfig::Angle rotations; - etl::smart_ptr shared_point; - - sinfg::Point origin; - sinfg::String name; - sinfg::Real scalar; + etl::smart_ptr shared_point; + + synfig::Point origin; + synfig::String name; + synfig::Real scalar; etl::handle origin_duck; etl::handle connect_duck; etl::handle box_duck; - sinfg::GUID guid_; + synfig::GUID guid_; // Flags bool editable; bool radius_; bool tangent_; - - sinfg::TransformStack transform_stack_; + bool hover_; + bool ignore_; + + synfig::TransformStack transform_stack_; - sinfgapp::ValueDesc value_desc_; + synfigapp::ValueDesc value_desc_; static int duck_count; public: Duck(); - Duck(const sinfg::Point &point); - Duck(const sinfg::Point &point,const sinfg::Point &origin); + Duck(const synfig::Point &point); + Duck(const synfig::Point &point,const synfig::Point &origin); ~Duck(); - - sigc::signal &signal_edited() { return signal_edited_; } + + sigc::signal &signal_edited() { return signal_edited_; } + sigc::signal &signal_edited_angle() { return signal_edited_angle_; } sigc::signal &signal_user_click(int i=0) { assert(i>=0); assert(i<5); return signal_user_click_[i]; } - void set_guid(const sinfg::GUID& x) { guid_=x; } - const sinfg::GUID& get_guid()const { return guid_; } + void set_guid(const synfig::GUID& x) { guid_=x; } + const synfig::GUID& get_guid()const { return guid_; } - sinfg::GUID get_data_guid()const; + synfig::GUID get_data_guid()const; //! Changes the editable flag. If set, the duck will not be able to be moved. void set_editable(bool x) { editable=x; } @@ -156,20 +170,32 @@ public: //! \writeme bool get_tangent()const { return tangent_; } + //! Sets whether to show the duck as if it is being hovered over + void set_hover(bool h) { hover_=h; } + + //! Retrieves whether to show the duck as if it is being hovered over + bool get_hover()const { return hover_; } + + //! Sets whether to ignore the duck when checking for user interaction + void set_ignore(bool i) { ignore_=i; } + + //! Retrieves whether to ignore the duck when checking for user interaction + bool get_ignore()const { return ignore_; } + void set_connect_duck(const etl::handle& x) { connect_duck=x; } void set_box_duck(const etl::handle& x) { box_duck=x; } const etl::handle& get_connect_duck()const { return connect_duck; } const etl::handle& get_box_duck()const { return box_duck; } - void set_value_desc(sinfgapp::ValueDesc x) { value_desc_=x; } + void set_value_desc(synfigapp::ValueDesc x) { value_desc_=x; } + + synfigapp::ValueDesc& get_value_desc() { return value_desc_; } - sinfgapp::ValueDesc& get_value_desc() { return value_desc_; } + void set_transform_stack(const synfig::TransformStack& x) { transform_stack_=x; } - void set_transform_stack(const sinfg::TransformStack& x) { transform_stack_=x; } + const synfig::TransformStack& get_transform_stack()const { return transform_stack_; } - const sinfg::TransformStack& get_transform_stack()const { return transform_stack_; } - //! \writeme void set_type(Type x) { type_=x; } @@ -177,51 +203,53 @@ public: Type get_type()const { return type_; } //! Sets the scalar multiplier for the duck with respect to the origin - void set_scalar(sinfg::Vector::value_type n) { scalar=n; } + void set_scalar(synfig::Vector::value_type n) { scalar=n; } //! Retrieves the scalar value - sinfg::Vector::value_type get_scalar()const { return scalar; } + synfig::Vector::value_type get_scalar()const { return scalar; } - void set_shared_point(const etl::smart_ptr&x) { shared_point=x; } + void set_shared_point(const etl::smart_ptr&x) { shared_point=x; } //! Sets the location of the duck with respect to the origin - void set_point(const sinfg::Point &x) { (shared_point?*shared_point:point)=x; } - + void set_point(const synfig::Point &x) { (shared_point?*shared_point:point)=x; } + //! Returns the location of the duck - sinfg::Point get_point()const { return shared_point?*shared_point:point; } - - sinfg::Point get_trans_point()const; - - void set_trans_point(const sinfg::Point &x); + synfig::Point get_point()const { return shared_point?*shared_point:point; } + + synfig::Angle get_rotations()const { return rotations; }; - sinfg::Point get_sub_trans_point()const; - void set_sub_trans_point(const sinfg::Point &x); - sinfg::Point get_sub_trans_origin()const; + synfig::Point get_trans_point()const; + + void set_trans_point(const synfig::Point &x); + + synfig::Point get_sub_trans_point()const; + void set_sub_trans_point(const synfig::Point &x); + synfig::Point get_sub_trans_origin()const; //! Sets the origin point. - void set_origin(const sinfg::Point &x); + void set_origin(const synfig::Point &x); //! Sets the origin point as another duck void set_origin(const etl::handle &x); //! Retrieves the origin location - sinfg::Point get_origin()const; - + synfig::Point get_origin()const; + //! Retrieves the origin duck - const etl::handle & get_origin_duck() const; + const etl::handle & get_origin_duck() const; //! Retrieves the origin location - sinfg::Point get_trans_origin()const; + synfig::Point get_trans_origin()const; void set_radius(bool r) { radius_=r; } bool is_radius()const { return radius_; } - + //! Sets the name of the duck - void set_name(const sinfg::String &x); + void set_name(const synfig::String &x); //! Retrieves the name of the duck - sinfg::String get_name()const { return name; } - + synfig::String get_name()const { return name; } + bool operator==(const Duck &rhs)const; }; // END of class Duck @@ -245,13 +273,13 @@ operator&(const Duck::Type lhs, const Duck::Type rhs) class DuckMap : public #ifdef HASH_MAP_H -__gnu_cxx::hash_map,sinfg::GUIDHash> +HASH_MAP_CLASS,synfig::GUIDHash> { - typedef __gnu_cxx::hash_map,sinfg::GUIDHash> PARENT_TYPE; + typedef HASH_MAP_CLASS,synfig::GUIDHash> PARENT_TYPE; #else -std::map > +std::map > { - typedef std::map > PARENT_TYPE; + typedef std::map > PARENT_TYPE; #endif public: void insert(const Duck::Handle& x) { operator[](x->get_guid())=x; }