gnomemm r1877 - in cluttermm/trunk: . clutter/src

[daniel svn gnome org]

Author: daniel
Date: Thu Dec 18 12:02:58 2008
New Revision: 1877
URL: http://svn.gnome.org/viewvc/gnomemm?rev=1877&view=rev

Log:
* clutter/src/alpha.{ccg,hg} (ALPHA_*): Replace global slot objects
for the convenience alpha functions by ordinary static methods of
class Alpha.  This is just as easy to use but simpler and without
the trouble associated with the runtime initialization  of global
objects in dynamic libraries.  Also adapt the code to the additions
and syntax changes in the Clutter API.
(Alpha::Alpha): Remove the ctor which takes a plain ClutterFunction
argument.  If absolutely necessary, there is always the C API.

Modified:
   cluttermm/trunk/ChangeLog
   cluttermm/trunk/clutter/src/alpha.ccg
   cluttermm/trunk/clutter/src/alpha.hg

Modified: cluttermm/trunk/clutter/src/alpha.ccg
==============================================================================
--- cluttermm/trunk/clutter/src/alpha.ccg	(original)
+++ cluttermm/trunk/clutter/src/alpha.ccg	Thu Dec 18 12:02:58 2008
@@ -17,25 +17,27 @@
 
 #include <clutter/clutter.h>
 
+namespace
+{
+
 static guint32 SignalProxy_Alpha_callback(ClutterAlpha *alpha, gpointer user_data)
 {
   guint32 value;
   Clutter::Alpha::SlotAlphaFunc* the_slot = static_cast<Clutter::Alpha::SlotAlphaFunc*>(user_data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+#endif
     Glib::RefPtr<Clutter::Alpha> cpp_alpha = Glib::wrap(alpha, true /* take reference */);
     value = (*the_slot)(cpp_alpha);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
+#endif
   return value;
 }
 
@@ -44,33 +46,115 @@
   delete static_cast<Clutter::Alpha::SlotAlphaFunc*>(data);
 }
 
+} // anonymous namespace
+
 namespace Clutter
 {
 
-Alpha::Alpha(const Glib::RefPtr<Timeline>& timeline, const SlotAlphaFunc& slot)
-:
-  _CONSTRUCT()
+guint32 Alpha::ramp_inc_func(const Glib::RefPtr<Alpha>& alpha)
 {
-  _INITIALLY_UNOWNED_SINK
-  set_timeline(timeline);
-  set_func(slot);
+  return clutter_ramp_inc_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::ramp_dec_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_ramp_dec_func(alpha->gobj(), 0);
 }
 
-Alpha::Alpha(const Glib::RefPtr<Timeline>& timeline, ClutterAlphaFunc callback)
+guint32 Alpha::ramp_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_ramp_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::sine_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_sine_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::sine_inc_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_sine_inc_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::sine_dec_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_sine_dec_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::sine_half_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_sine_half_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::sine_in_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_sine_in_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::sine_out_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_sine_out_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::sine_in_out_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_sine_in_out_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::square_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_square_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::smoothstep_inc_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_smoothstep_inc_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::smoothstep_dec_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_smoothstep_dec_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::exp_inc_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_exp_inc_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::exp_dec_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_exp_dec_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::ease_in_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_ease_in_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::ease_out_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_ease_out_func(alpha->gobj(), 0);
+}
+
+guint32 Alpha::ease_in_out_func(const Glib::RefPtr<Alpha>& alpha)
+{
+  return clutter_ease_in_out_func(alpha->gobj(), 0);
+}
+
+Alpha::Alpha(const Glib::RefPtr<Timeline>& timeline, const SlotAlphaFunc& slot)
 :
   _CONSTRUCT()
 {
   _INITIALLY_UNOWNED_SINK
   set_timeline(timeline);
-  clutter_alpha_set_func(gobj(), callback, NULL, NULL);
+  set_func(slot);
 }
 
-
 void Alpha::set_func(const SlotAlphaFunc& slot)
 {
   //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
   //It will be deleted when SignalProxy_Alpha_callback_destroy() is called.
-  SlotAlphaFunc* slot_copy = new SlotAlphaFunc(slot);
+  SlotAlphaFunc *const slot_copy = new SlotAlphaFunc(slot);
 
   clutter_alpha_set_func(
       gobj(),
@@ -78,32 +162,4 @@
       &SignalProxy_Alpha_callback_destroy);
 }
 
-static guint32
-alpha_slot_proxy(const Glib::RefPtr<Alpha>& alpha, ClutterAlphaFunc c_func)
-{
-    return c_func(alpha->gobj (), NULL);
-}
-
-inline static
-Alpha::SlotAlphaFunc generate_alpha_slot_proxy (ClutterAlphaFunc func)
-{
-    return sigc::bind (sigc::ptr_fun(alpha_slot_proxy), func);
-}
-
-#if 0
-Alpha::SlotAlphaFunc ALPHA_RAMP_INC = generate_alpha_slot_proxy(CLUTTER_ALPHA_RAMP_INC);
-Alpha::SlotAlphaFunc ALPHA_RAMP_DEC = generate_alpha_slot_proxy(CLUTTER_ALPHA_RAMP_DEC);
-Alpha::SlotAlphaFunc ALPHA_RAMP = generate_alpha_slot_proxy(CLUTTER_ALPHA_RAMP);
-Alpha::SlotAlphaFunc ALPHA_SINE = generate_alpha_slot_proxy(CLUTTER_ALPHA_SINE);
-Alpha::SlotAlphaFunc ALPHA_SINE_INC = generate_alpha_slot_proxy(CLUTTER_ALPHA_SINE_INC);
-Alpha::SlotAlphaFunc ALPHA_SINE_DEC = generate_alpha_slot_proxy(CLUTTER_ALPHA_SINE_DEC);
-Alpha::SlotAlphaFunc ALPHA_SINE_HALF = generate_alpha_slot_proxy(CLUTTER_ALPHA_SINE_HALF);
-Alpha::SlotAlphaFunc ALPHA_SQUARE = generate_alpha_slot_proxy(CLUTTER_ALPHA_SQUARE);
-Alpha::SlotAlphaFunc ALPHA_SMOOTHSTEP_INC = generate_alpha_slot_proxy(CLUTTER_ALPHA_SMOOTHSTEP_INC);
-Alpha::SlotAlphaFunc ALPHA_SMOOTHSTEP_DEC = generate_alpha_slot_proxy(CLUTTER_ALPHA_SMOOTHSTEP_DEC);
-Alpha::SlotAlphaFunc ALPHA_EXP_INC = generate_alpha_slot_proxy(CLUTTER_ALPHA_EXP_INC);
-Alpha::SlotAlphaFunc ALPHA_EXP_DEC = generate_alpha_slot_proxy(CLUTTER_ALPHA_EXP_DEC);
-#endif
-
-} //namespace Clutter
-
+} // namespace Clutter

Modified: cluttermm/trunk/clutter/src/alpha.hg
==============================================================================
--- cluttermm/trunk/clutter/src/alpha.hg	(original)
+++ cluttermm/trunk/clutter/src/alpha.hg	Thu Dec 18 12:02:58 2008
@@ -22,7 +22,6 @@
 _DEFS(cluttermm,clutter)
 _PINCLUDE(glibmm/private/object_p.h)
 
-
 namespace Clutter
 {
 
@@ -31,42 +30,53 @@
   _CLASS_GOBJECT(Alpha, ClutterAlpha, CLUTTER_ALPHA, Glib::Object, GObject)
   _DERIVES_INITIALLY_UNOWNED()
 
-protected:
-  _CTOR_DEFAULT()
-
 public:
-
   /** For instance,
    * guint32 on_alpha(const Glib::RefPtr<Alpha>& alpha);
    */
-  typedef sigc::slot<guint32, const Glib::RefPtr<Alpha>& > SlotAlphaFunc;
+  typedef sigc::slot<guint32, const Glib::RefPtr<Alpha>&> SlotAlphaFunc;
+
+  //! @name Pre-defined Alpha Functions
+  //! @{
+  static guint32 ramp_inc_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 ramp_dec_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 ramp_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 sine_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 sine_inc_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 sine_dec_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 sine_half_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 sine_in_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 sine_out_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 sine_in_out_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 square_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 smoothstep_inc_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 smoothstep_dec_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 exp_inc_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 exp_dec_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 ease_in_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 ease_out_func(const Glib::RefPtr<Alpha>& alpha);
+  static guint32 ease_in_out_func(const Glib::RefPtr<Alpha>& alpha);
+  //! @}
 
 protected:
-  /** Creates a new Alpha instance and sets the timeline and the alpha function.
-   * @param timeline Timeline.
-   * @param slot Alpha function.
-   */
-  Alpha(const Glib::RefPtr<Timeline>& timeline, const SlotAlphaFunc& slot);
+  _CTOR_DEFAULT()
 
   /** Creates a new Alpha instance and sets the timeline and the alpha function.
    * @param timeline Timeline.
    * @param slot Alpha function.
    */
-  Alpha(const Glib::RefPtr<Timeline>& timeline, ClutterAlphaFunc callback);
+  Alpha(const Glib::RefPtr<Timeline>& timeline, const SlotAlphaFunc& slot);
 
 public:
   _WRAP_CREATE()
   _WRAP_CREATE(const Glib::RefPtr<Timeline>& timeline, const SlotAlphaFunc& slot)
-  _WRAP_CREATE(const Glib::RefPtr<Timeline>& timeline, ClutterAlphaFunc callback)
-
-
 
   _WRAP_METHOD(void set_timeline(const Glib::RefPtr<Timeline>& timeline), clutter_alpha_set_timeline)
   _WRAP_METHOD(Glib::RefPtr<Timeline> get_timeline() const, clutter_alpha_get_timeline)
   _WRAP_METHOD(guint32 get_alpha() const, clutter_alpha_get_alpha)
 
-  void set_func(const SlotAlphaFunc& slot);
   _IGNORE(clutter_alpha_set_func)
+  void set_func(const SlotAlphaFunc& slot);
 
   _WRAP_PROPERTY("alpha", guint)
   _WRAP_PROPERTY("timeline", Glib::RefPtr<Timeline>)
@@ -75,24 +85,4 @@
   _IGNORE(clutter_alpha_set_closure)
 };
 
-/// @name Pre-defined Alpha functions
-/// @related Alpha
-/// @{
-#if 0
-extern Alpha::SlotAlphaFunc ALPHA_RAMP_INC;
-extern Alpha::SlotAlphaFunc ALPHA_RAMP_DEC;
-extern Alpha::SlotAlphaFunc ALPHA_RAMP;
-extern Alpha::SlotAlphaFunc ALPHA_SINE;
-extern Alpha::SlotAlphaFunc ALPHA_SINE_INC;
-extern Alpha::SlotAlphaFunc ALPHA_SINE_DEC;
-extern Alpha::SlotAlphaFunc ALPHA_SINE_HALF;
-extern Alpha::SlotAlphaFunc ALPHA_SQUARE;
-extern Alpha::SlotAlphaFunc ALPHA_SMOOTHSTEP_INC;
-extern Alpha::SlotAlphaFunc ALPHA_SMOOTHSTEP_DEC;
-extern Alpha::SlotAlphaFunc ALPHA_EXP_INC;
-extern Alpha::SlotAlphaFunc ALPHA_EXP_DEC;
-#endif
-/// @}
-
 } // namespace Clutter
-// vim:ts=2,sw=2