This macro declares a wrapper for a type that is derived from GObject, but whose wrapper is not derived from Gtk::Object.

_CLASS_GOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )

For instance, from accelgroup.hg:

_CLASS_GOBJECT(AccelGroup, GtkAccelGroup, GTK_ACCEL_GROUP, Glib::Object, GObject)

This macro declares a wrapper for a type whose wrapper is derived from Gtk::Object, such as a widget or dialog.

_CLASS_GTKOBJECT( C++ class, C class, C casting macro, C++ base class, C base class )

For instance, from button.hg:

_CLASS_GTKOBJECT(Button, GtkButton, GTK_BUTTON, Gtk::Bin, GtkBin)

You will typically use this macro when the class already derives from Gtk::Object. For instance, you will use it when wrapping a GTK+ Widget, because Gtk::Widget derives from Gtk::Object.

You might also derive non-widget classes from Gtk::Object so they can be used without Glib::RefPtr. For instance, they could then be instantiated with Gtk::make_managed() or on the stack as a member variable. This is convenient, but you should use this only when you are sure that true reference-counting is not needed. We consider it useful for widgets.

This macro declares a wrapper for a non-GObject struct, registered with g_boxed_type_register_static().

_CLASS_BOXEDTYPE( C++ class, C class, new function, copy function, free function )

For instance, from Gdk::RGBA:

_CLASS_BOXEDTYPE(RGBA, GdkRGBA, NONE, gdk_rgba_copy, gdk_rgba_free)

This macro declares a wrapper for a simple assignable struct such as GdkRectangle. It is similar to _CLASS_BOXEDTYPE, but the C struct is not allocated dynamically.

_CLASS_BOXEDTYPE_STATIC( C++ class, C class )

For instance, for Gdk::Rectangle:

_CLASS_BOXEDTYPE_STATIC(Rectangle, GdkRectangle)

This macro declares a wrapper for an opaque struct that has copy and free functions. The new, copy and free functions will be used to instantiate the default constructor, copy constructor and destructor.

_CLASS_OPAQUE_COPYABLE( C++ class, C class, new function, copy function, free function )

For instance, from Glib::Checksum:

_CLASS_OPAQUE_COPYABLE(Checksum, GChecksum, NONE, g_checksum_copy, g_checksum_free)

This macro declares a wrapper for a reference-counted opaque struct. The C++ wrapper cannot be directly instantiated and can only be used with Glib::RefPtr.

_CLASS_OPAQUE_REFCOUNTED( C++ class, C class, new function, ref function, unref function )

For instance, for Pango::Coverage:

_CLASS_OPAQUE_REFCOUNTED(Coverage, PangoCoverage, pango_coverage_new, pango_coverage_ref, pango_coverage_unref)

This macro can be used to wrap structs which don't fit into any specialized category.

_CLASS_GENERIC( C++ class, C class )

For instance, for Pango::AttrIter:

_CLASS_GENERIC(AttrIter, PangoAttrIterator)

This macro declares a wrapper for a type that is derived from GTypeInterface.

_CLASS_INTERFACE( C++ class, C class, C casting macro, C interface struct, Base C++ class (optional), Base C class (optional) )

For instance, from celleditable.hg:

_CLASS_INTERFACE(CellEditable, GtkCellEditable, GTK_CELL_EDITABLE, GtkCellEditableIface)

Two extra parameters are optional, for the case that the interface derives from another interface, which should be the case when the GInterface has another GInterface as a prerequisite. For instance, from loadableicon.hg:

_CLASS_INTERFACE(LoadableIcon, GLoadableIcon, G_LOADABLE_ICON, GLoadableIconIface, Icon, GIcon)

This macro creates a default constructor with no arguments.

This macro creates a constructor with arguments, equivalent to a *_new() C function. It won't actually call the *_new() function, but will simply create an equivalent constructor with the same argument types. It takes a C++ constructor signature, and a C function name.

It also takes an optional extra argument:

When a constructor must be partly hand written because, for instance, the *_new() C function's parameters do not correspond directly to object properties, or because the *_new() C function does more than call g_object_new(), the _CONSTRUCT() macro may be used in the .ccg file to save some work. The _CONSTRUCT macro takes a series of property names and values. For instance, from button.ccg:

Button::Button(const Glib::ustring& label, bool mnemonic)
:
  _CONSTRUCT("label", label.c_str(), "use_underline", gboolean(mnemonic))
{}

Suppresses declaration and definition of default constructor in _CLASS_BOXEDTYPE, _CLASS_BOXEDTYPE_STATIC and _CLASS_OPAQUE_COPYABLE.

Suppresses declaration and definition of the constructor that takes a pointer to the wrapped C object in _CLASS_BOXEDTYPE and _CLASS_BOXEDTYPE_STATIC.

Suppresses definition of the constructor that takes a pointer to the wrapped C object in _CLASS_GOBJECT, _CLASS_GTKOBJECT, _CLASS_INTERFACE and _CLASS_OPAQUE_COPYABLE.

Suppresses definition of destructor in _CLASS_GOBJECT and _CLASS_GTKOBJECT.

Suppresses declaration and definition of move constructor and move assignment operator in _CLASS_GOBJECT.

For example:

class Derived : public Glib::Object
{
  _CLASS_GOBJECT(Derived, GDerived, G_DERIVED, Glib::Object, GObject)

  _CUSTOM_MOVE_OPERATIONS

public:
  Derived(Derived&& src) noexcept;
  Derived& operator=(Derived&& src) noexcept;
  // ...
};

Suppresses definition of Glib::wrap_new() function in _CLASS_GOBJECT.

Suppresses definition of Glib::wrap() function in _CLASS_GOBJECT and _CLASS_GTKOBJECT.

Suppresses declaration and definition of Glib::wrap() function in _CLASS_GOBJECT, _CLASS_BOXEDTYPE, _CLASS_BOXEDTYPE_STATIC, _CLASS_OPAQUE_COPYABLE, _CLASS_INTERFACE and _CLASS_GTKOBJECT.

This macro generates the C++ method to wrap a C function.

_WRAP_METHOD( C++ method signature, C function name)

For instance, from entry.hg:

_WRAP_METHOD(void set_text(const Glib::ustring& text), gtk_entry_set_text)

The C function (e.g. gtk_entry_set_text) is described more fully in the .defs file, and the convert*.m4 files contain the necessary conversion from the C++ parameter type to the C parameter type. This macro also generates doxygen documentation comments based on the *_docs.xml and *_docs_override.xml files.

There are some optional extra arguments:

Selecting which C++ types should be used is also important when wrapping C API. Though it's usually obvious what C++ types should be used in the C++ method, here are some hints:

This macro is like _WRAP_METHOD(), but it generates only the documentation for a C++ method that wraps a C function. Use this when you must hand-code the method, but you want to use the documentation that would be generated if the method was generated.

_WRAP_METHOD_DOCS_ONLY(C function name)

For instance, from container.hg:

_WRAP_METHOD_DOCS_ONLY(gtk_container_remove)

There are some optional extra arguments:

gmmproc will warn you on stdout about functions, signals, properties and child properties that you have forgotten to wrap, helping to ensure that you are wrapping the complete API. But if you don't want to wrap some functions, signals, properties or child properties, or if you chose to hand-code some methods then you can use the _IGNORE(), _IGNORE_SIGNAL(), _IGNORE_PROPERTY() or _IGNORE_CHILD_PROPERTY() macro to make gmmproc stop complaining.

For instance, from flowbox.hg:

_IGNORE(gtk_flow_box_set_filter_func, gtk_flow_box_set_sort_func)
_IGNORE_SIGNAL(activate-cursor-child, toggle-cursor-child, move-cursor)

This macro generates the C++ libsigc++-style signal to wrap a C GObject signal. It actually generates a public accessor method, such as signal_clicked(), which returns a proxy object. gmmproc uses the .defs file to discover the C parameter types and the .m4 convert files to discover appropriate type conversions.

_WRAP_SIGNAL( C++ signal handler signature, C signal name)

For instance, from button.hg:

_WRAP_SIGNAL(void clicked(),"clicked")

Signals usually have function pointers in the GTK struct, with a corresponding enum value and a g_signal_new() in the .c file.

There are some optional extra arguments:

This macro generates the C++ method to wrap a C GObject property. You must specify the property name and the wanted C++ type for the property. gmmproc uses the .defs file to discover the C type and the .m4 convert files to discover appropriate type conversions.

_WRAP_PROPERTY(C property name, C++ type)

For instance, from button.hg:

_WRAP_PROPERTY("label", Glib::ustring)

There are some optional extra arguments:

This macro generates the C++ method to wrap a virtual C function.

_WRAP_VFUNC( C++ method signature, C function name)

For instance, from widget.hg:

_WRAP_VFUNC(SizeRequestMode get_request_mode() const, get_request_mode)

The C function (e.g. get_request_mode) is described more fully in the *_vfuncs.defs file, and the convert*.m4 files contain the necessary conversion from the C++ parameter type to the C parameter type. Conversions can also be written in the .hg file. Virtual functions often require special conversions that are best kept local to the .hg file where they are used.

There are some optional extra arguments:

A rule to which there may be exceptions: If the virtual C function returns a pointer to an object derived from GObject, i.e. a reference-counted object, then the virtual C++ function shall return a Glib::RefPtr<> object. One of the extra arguments refreturn or refreturn_ctype is required.

This macro generates the C++ method to wrap a GtkContainer child property. (See GtkContainer for more information about child properties). Similarly to _WRAP_PROPERTY, you must specify the property name and the wanted C++ type for the property. gmmproc uses the .defs file to discover the C type and the .m4 convert files to discover appropriate type conversions.

_WRAP_CHILD_PROPERTY(C child property name, C++ type)

For instance, from notebook.hg:

_WRAP_CHILD_PROPERTY("tab-expand", bool)

_WRAP_CHILD_PROPERTY() accepts the same optional arguments as _WRAP_PROPERTY().

This macro generates initialization code for the interface.

_IMPLEMENTS_INTERFACE(C++ interface name)

For instance, from grid.hg:

_IMPLEMENTS_INTERFACE(Orientable)

There is one optional extra argument:

This macro generates a C++ enum to wrap a C enum. You must specify the desired C++ name and the name of the underlying C enum.

For instance, from enums.hg:

_WRAP_ENUM(WindowType, GtkWindowType)

There are some optional extra arguments:

This macro just generates a Doxygen documentationn block for the enum. This is useful for enums that can't be wrapped with _WRAP_ENUM() because they are complexly defined (maybe using C macros) but including the generated enum documentation is still desired. It is used with the same syntax as _WRAP_ENUM() and also process the same options (though NO_GTYPE is just ignored because it makes no difference when just generating the enum's documentation).

This macro generates a C++ exception class, derived from Glib::Error, with a Code enum and a code() method. You must specify the desired C++ name, the name of the corresponding C enum, and the prefix for the C enum values.

This exception can then be thrown by methods which are generated from _WRAP_METHOD() with the errthrow option.

For instance, from pixbuf.hg:

_WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)

_WRAP_GERROR() accepts the same optional arguments as _WRAP_ENUM().

Use these macros if you're wrapping a simple struct or boxed type that provides direct access to its data members, to create getters and setters for the data members.

_MEMBER_GET(C++ name, C name, C++ type, C type)

_MEMBER_SET(C++ name, C name, C++ type, C type)

For example, in rectangle.hg:

_MEMBER_GET(x, x, int, int)

Use these macros to automatically provide getters and setters for a data member that is a pointer type. For the getter function, it will create two methods, one const and one non-const.

_MEMBER_GET_PTR(C++ name, C name, C++ type, C type)

_MEMBER_SET_PTR(C++ name, C name, C++ type, C type)

For example, for Pango::Analysis in item.hg:

// _MEMBER_GET_PTR(engine_lang, lang_engine, EngineLang*, PangoEngineLang*)
// It's just a comment. It's difficult to find a real-world example.

Use these macros to provide getters and setters for a data member that is a GObject type that must be referenced before being returned.

_MEMBER_GET_GOBJECT(C++ name, C name, C++ type, C type)

_MEMBER_SET_GOBJECT(C++ name, C name, C++ type, C type)

For example, in Pangomm, layoutline.hg:

_MEMBER_GET_GOBJECT(layout, layout, Pango::Layout, PangoLayout*)

For all the macros that process method signatures, it is possible to specify a different order for the C++ parameters than the existing order in the C function, virtual function or signal. For example, say that the following C function were being wrapped as a C++ method for the Gtk::Widget class:

        void gtk_widget_set_device_events(GtkWidget* widget, GdkDevice* device,
        GdkEventMask events);
      

However, changing the order of the C++ method's two parameters is necessary. Something like the following would wrap the function as a C++ method with a different order for the two parameters:

        _WRAP_METHOD(void set_device_events(Gdk::EventMask events{events},
        const Glib::RefPtr<const Gdk::Device>& device{device}),
        gtk_widget_set_device_events)
      

The {c_param_name} following the method parameter names tells gmmproc to map the C++ parameter to the specified C parameter within the {}. Since the C++ parameter names correspond to the C ones, the above could be re-written as:

        _WRAP_METHOD(void set_device_events(Gdk::EventMask events{.}, const
        Glib::RefPtr<const Gdk::Device>& device{.}),
        gtk_widget_set_device_events)
      

	Warning
	Please note that when reordering parameters for a _WRAP_SIGNAL() method signature, the C parameter names would always be p0, p1, etc. because the generate_extra_defs utility uses those parameter names no matter what the C API's parameter names may be. It's how the utility is written presently.

For all macros processing method signatures except _WRAP_SIGNAL() and _WRAP_VFUNC() it is also possible to make the parameters optional so that extra C++ methods are generated without the specified optional parameter. For example, say that the following *_new() function were being wrapped as a constructor in the Gtk::ToolButton class:

        GtkToolItem* gtk_tool_button_new(GtkWidget* icon_widget, const gchar*
        label);
      

Also, say that the C API allowed NULL for the function's label parameter so that that parameter is optional. It would be possible to have gmmproc generate the original constructor (with all the parameters) along with an additional constructor without that optional parameter by appending a {?} to the parameter name like so:

        _WRAP_CTOR(ToolButton(Widget& icon_widget, const Glib::ustring&
        label{?}), gtk_tool_button_new)
      

In this case, two constructors would be generated: One with the optional parameter and one without it.

With _WRAP_METHOD() it is also possible for the return of the wrapped C function (if it has one) to be placed in an output parameter of the C++ method instead of having the C++ method also return a value like the C function does. To do that, simply include the output parameter in the C++ method parameter list appending a {OUT} to the output parameter name. For example, if gtk_widget_get_request_mode() is declared as the following:

        GtkSizeRequestMode gtk_widget_get_request_mode(GtkWidget* widget);
      

And having the C++ method set an output parameter is desired instead of returning a SizeRequestMode, something like the following could be used:

        _WRAP_METHOD(void get_request_mode(SizeRequestMode& mode{OUT})
        const, gtk_widget_get_request_mode)
      

The {OUT} appended to the name of the mode output parameter tells gmmproc to place the return of the C function in that output parameter. In this case, however, a necessary initialization macro like the following would also have to be specified:

        _INITIALIZATION(`SizeRequestMode&',`GtkSizeRequestMode',`$3 =
        (SizeRequestMode)($4)')
      

Which could also be written as:

        _INITIALIZATION(`SizeRequestMode&',`GtkSizeRequestMode',`$3 =
        ($1)($4)')
      

_WRAP_METHOD() also supports setting C++ output parameters from C output parameters if the C function being wrapped has any. Suppose, for example, that we want to wrap the following C function that returns a value in its C output parameter rect:

        gboolean gtk_icon_view_get_cell_rect(GtkIconView* icon_view,
        GtkTreePath* path, GtkCellRenderer* cell, GdkRectangle* rect);
      

To have gmmproc place the value returned in the C++ rect output parameter, something like the following _WRAP_METHOD() directive could be used:

        _WRAP_METHOD(bool get_cell_rect(const TreeModel::Path& path, const
        CellRenderer& cell, Gdk::Rectangle& rect{>>}) const,
        gtk_icon_view_get_cell_rect)
      

The {>>} following the rect parameter name indicates that the C++ output parameter should be set from the value returned in the C parameter from the C function. gmmproc will generate a declaration of a temporary variable in which to store the value of the C output parameter and a statement that sets the C++ output parameter from the temporary variable. In this case it may be necessary to have an _INITIALIZATION() describing how to set a Gdk::Rectangle& from a GdkRectangle* such as the following:

        _INITIALIZATION(`Gdk::Rectangle&',`GdkRectangle', `$3 =
        Glib::wrap(&($4))')
      

A string-valued input parameter in a C++ method is usually a const Glib::ustring& or a const std::string&. In C code it's a const gchar*. When an empty string is converted to const gchar*, it can be converted either to nullptr or to a pointer to an empty string (with c_str()). Some parameters in some C functions accept a nullptr, and interpret it in a special way. Other parameters must not be nullptr.

The default conversion in _WRAP_METHOD() and similar directives is

If the default conversion is not the best conversion, append {NULL} to a mandatory parameter or {?!NULL} to an optional parameter (!NULL = not NULL). If you append both a C parameter name and NULL, separate them with a space: {c_param_name NULL}.