1 files changed, 419 insertions, 0 deletions
diff --git a/libs/gtkmm2/gtk/gtkmm/actiongroup.cc b/libs/gtkmm2/gtk/gtkmm/actiongroup.cc
new file mode 100644
index 0000000000..d539b9ab5e
--- /dev/null
+++ b/libs/gtkmm2/gtk/gtkmm/actiongroup.cc
@@ -0,0 +1,419 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <gtkmm/actiongroup.h>
+#include <gtkmm/private/actiongroup_p.h>
+
+// -*- c++ -*-
+/* $Id$ */
+
+/* Copyright 2003 The gtkmm Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <gtk/gtkactiongroup.h>
+#include <gtkmm/accelmap.h>
+
+
+namespace Gtk
+{
+
+void ActionGroup::add(const Glib::RefPtr<Action>& action)
+{
+  gtk_action_group_add_action_with_accel(gobj(), Glib::unwrap(action),
+    0 /* accelerator=0 means use the stock accelerator if this is a stock item */ );
+}
+
+void ActionGroup::add(const Glib::RefPtr<Action>& action, const AccelKey& accel_key)
+{
+  // We need to half-duplicate the gtk_action_group_add_action_with_accel() implementation, because we want to
+  // use AccelKey, not just the accelerator string format that is _one_ of the ways to create an AccelKey. murrayc.
+
+  //The AccelKey might have been constructed from key+mod or from an accelerator string,
+  //but it the end that just produces a key+mod.
+  guint key = accel_key.get_key();
+  Gdk::ModifierType mod = accel_key.get_mod();
+  if(key)
+  {
+    // The AccelKey constructor can take an accel path, so I suppose we should not ignore it,
+    // but I can't imagine how it would be useful with the UIManager. murrayc.
+    Glib::ustring accel_path = accel_key.get_path();
+    if(accel_path.empty())
+    {
+      //Copied from the gtk_action_group_add_action_with_accel() implementation:
+      accel_path =  "<Actions>/" + get_name() + "/" + action->property_name();
+    }
+    
+    AccelMap::add_entry(accel_path, key, mod);
+
+    action->set_accel_path(accel_path);
+  }
+
+  gtk_action_group_add_action(gobj(), action->gobj());
+}
+
+  
+void ActionGroup::add(const Glib::RefPtr<Action>& action, const Action::SlotActivate& slot)
+{
+  //This is meant to be similar to the gtk_action_group_add_actions() convenience method that is used from C.
+  //This also does the work of gtk_action_group_add_toggle_actions() and gtk_action_group_add_radio_actions_full(),
+  //because the extra stuff there is already done when the Action (or a derived type, such as ToggleAction) is create()ed.
+  
+  action->signal_activate().connect(slot);
+  
+  //We probably don't need to use translate_string(), because the label and tooltip will be regular translated strings in our C++ application code.
+  //But C needs it because gtk_action_group_add_actions() takes a static array of GtkActionEntrys  whose fields 
+  //can not be translated with gettext macros.
+  //But we should soon know if menus and toolbars are not translated in non-english locales. murrayc.
+  
+  add(action);
+}
+
+void ActionGroup::add(const Glib::RefPtr<Action>& action, const AccelKey& accel_key, const Action::SlotActivate& slot)
+{
+  //This is meant to be similar to the gtk_action_group_add_actions() convenience method that is used from C.
+  //This also does the work of gtk_action_group_add_toggle_actions() and gtk_action_group_add_radio_actions_full(),
+  //because the extra stuff there is already done when the Action (or a derived type, such as ToggleAction) is create()ed.
+
+  action->signal_activate().connect(slot);
+  add(action, accel_key);
+
+  /*
+  //Create the accel path (a kind of unique key):
+  Glib::ustring accel_path = "<Actions>/" + get_name() + "/" + action->get_name();
+
+  //Register the accel path:
+  Gtk::AccelMap::add_entry(accel_path, accel_key.get_key(), accel_key.get_mod());
+
+  //USe the accel path:
+  action->set_accel_path(accel_path);
+  */
+}  
+
+
+} // namespace Gtk
+
+
+namespace
+{
+
+void ActionGroup_signal_connect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_connect_proxy_info =
+{
+  "connect_proxy",
+  (GCallback) &ActionGroup_signal_connect_proxy_callback,
+  (GCallback) &ActionGroup_signal_connect_proxy_callback
+};
+
+
+void ActionGroup_signal_disconnect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+, Glib::wrap(p1)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_disconnect_proxy_info =
+{
+  "disconnect_proxy",
+  (GCallback) &ActionGroup_signal_disconnect_proxy_callback,
+  (GCallback) &ActionGroup_signal_disconnect_proxy_callback
+};
+
+
+void ActionGroup_signal_pre_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_pre_activate_info =
+{
+  "pre_activate",
+  (GCallback) &ActionGroup_signal_pre_activate_callback,
+  (GCallback) &ActionGroup_signal_pre_activate_callback
+};
+
+
+void ActionGroup_signal_post_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
+
+  // Do not try to call a signal on a disassociated wrapper.
+  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
+  {
+    try
+    {
+      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
+        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo ActionGroup_signal_post_activate_info =
+{
+  "post_activate",
+  (GCallback) &ActionGroup_signal_post_activate_callback,
+  (GCallback) &ActionGroup_signal_post_activate_callback
+};
+
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::ActionGroup> wrap(GtkActionGroup* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::ActionGroup>( dynamic_cast<Gtk::ActionGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& ActionGroup_Class::init()
+{
+  if(!gtype_) // create the GType if necessary
+  {
+    // Glib::Class has to know the class init function to clone custom types.
+    class_init_func_ = &ActionGroup_Class::class_init_function;
+
+    // This is actually just optimized away, apparently with no harm.
+    // Make sure that the parent type has been created.
+    //CppClassParent::CppObjectType::get_type();
+
+    // Create the wrapper type, with the same class/instance size as the base type.
+    register_derived_type(gtk_action_group_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void ActionGroup_Class::class_init_function(void* g_class, void* class_data)
+{
+  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
+  CppClassParent::class_init_function(klass, class_data);
+
+}
+
+
+Glib::ObjectBase* ActionGroup_Class::wrap_new(GObject* object)
+{
+  return new ActionGroup((GtkActionGroup*)object);
+}
+
+
+/* The implementation: */
+
+GtkActionGroup* ActionGroup::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+ActionGroup::ActionGroup(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+ActionGroup::ActionGroup(GtkActionGroup* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+ActionGroup::~ActionGroup()
+{}
+
+
+ActionGroup::CppClassType ActionGroup::actiongroup_class_; // initialize static member
+
+GType ActionGroup::get_type()
+{
+  return actiongroup_class_.init().get_type();
+}
+
+GType ActionGroup::get_base_type()
+{
+  return gtk_action_group_get_type();
+}
+
+
+ActionGroup::ActionGroup(const Glib::ustring& name)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(actiongroup_class_.init(), "name", name.c_str(), (char*) 0))
+{
+  }
+
+Glib::RefPtr<ActionGroup> ActionGroup::create(const Glib::ustring& name)
+{
+  return Glib::RefPtr<ActionGroup>( new ActionGroup(name) );
+}
+Glib::ustring ActionGroup::get_name() const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_action_group_get_name(const_cast<GtkActionGroup*>(gobj())));
+}
+
+bool ActionGroup::get_sensitive() const
+{
+  return gtk_action_group_get_sensitive(const_cast<GtkActionGroup*>(gobj()));
+}
+
+void ActionGroup::set_sensitive(bool sensitive)
+{
+  gtk_action_group_set_sensitive(gobj(), static_cast<int>(sensitive));
+}
+
+bool ActionGroup::get_visible() const
+{
+  return gtk_action_group_get_visible(const_cast<GtkActionGroup*>(gobj()));
+}
+
+void ActionGroup::set_visible(bool visible)
+{
+  gtk_action_group_set_visible(gobj(), static_cast<int>(visible));
+}
+
+Glib::RefPtr<Action> ActionGroup::get_action(const Glib::ustring& action_name)
+{
+
+  Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_action_group_get_action(gobj(), action_name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::RefPtr<const Action> ActionGroup::get_action(const Glib::ustring& action_name) const
+{
+
+  Glib::RefPtr<const Action> retvalue = Glib::wrap(gtk_action_group_get_action(const_cast<GtkActionGroup*>(gobj()), action_name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+Glib::ListHandle< Glib::RefPtr<Action> > ActionGroup::get_actions()
+{
+  return Glib::ListHandle< Glib::RefPtr<Action> >(gtk_action_group_list_actions(gobj()), Glib::OWNERSHIP_SHALLOW);
+}
+
+Glib::ListHandle< Glib::RefPtr<const Action> > ActionGroup::get_actions() const
+{
+  return Glib::ListHandle< Glib::RefPtr<const Action> >(gtk_action_group_list_actions(const_cast<GtkActionGroup*>(gobj())), Glib::OWNERSHIP_SHALLOW);
+}
+
+void ActionGroup::remove(const Glib::RefPtr<Action>& action)
+{
+  gtk_action_group_remove_action(gobj(), Glib::unwrap(action));
+}
+
+Glib::ustring ActionGroup::translate_string(const Glib::ustring& str) const
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(gtk_action_group_translate_string(const_cast<GtkActionGroup*>(gobj()), str.c_str()));
+}
+
+
+Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > ActionGroup::signal_connect_proxy()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &ActionGroup_signal_connect_proxy_info);
+}
+
+Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > ActionGroup::signal_disconnect_proxy()
+{
+  return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &ActionGroup_signal_disconnect_proxy_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > ActionGroup::signal_pre_activate()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &ActionGroup_signal_pre_activate_info);
+}
+
+Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > ActionGroup::signal_post_activate()
+{
+  return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &ActionGroup_signal_post_activate_info);
+}
+
+
+} // namespace Gtk
+
+