Los archivos .hg y .ccg

Esta macro declara un envoltorio de un tipo que deriva de GObject, pero cuyo envoltorio no deriva de Gtk::Object.

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

For instance, from adjustment.hg:

_CLASS_GOBJECT(Adjustment, GtkAdjustment, GTK_ADJUSTMENT, Glib::Object, GObject)

Esta macro declara un envoltorio para un tipo cuyo envoltorio deriva de Gtk::Object, como un widget o un diálogo.

_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::Widget, GtkWidget)

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.

Esta macro declara un envoltorio para una estructura que no es GObject, registrada con 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)

Esta macro declara un envoltorio para una estructura asignable simple como GdkRectangle. Es similar a _CLASS_BOXEDTYPE, pero la estructura de C no se asigna dinámicamente.

_CLASS_BOXEDTYPE_STATIC( C++ class, C class )

For instance, for Gdk::Rectangle:

_CLASS_BOXEDTYPE_STATIC(Rectangle, GdkRectangle)

Esta macro declara un envoltorio para una estructura opaca que tiene funciones «copy» y «free». Las funciones «new», «copy» y «free» se usarán para instanciar el constructor predeterminado, copiar el constructor y el destructor.

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

For instance, from Glib::VariantType:

_CLASS_OPAQUE_COPYABLE(VariantType, GVariantType, NONE, g_variant_type_copy, g_variant_type_free)

Esta macro declara un envoltorio para una estructura opaca con conteo de referencias. El envoltorio de C++ no puede instanciarse directamente y sólo lo puede usar Glib::RefPtr.

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

For instance, for Gtk::CssSection:

_CLASS_OPAQUE_REFCOUNTED(CssSection, GtkCssSection, NONE, gtk_css_section_ref, gtk_css_section_unref)

Esta macro puede usarse para envolver estructuras que no se ajustan a ninguna categoría especializada.

_CLASS_GENERIC( C++ class, C class )

For instance, for Gdk::TimeCoord:

_CLASS_GENERIC(TimeCoord, GdkTimeCoord)

Esta macro declara un envoltorio para un tipo que deriva de 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 optional parameters were once added, for the case that the interface derives from another interface, which was believed to be the case when the GInterface has another GInterface as a prerequisite. This is a misunderstanding, though. When GInterface A has GInterface B as a prerequisite, it means that every class that implements A shall also implement B. For instance, from loadableicon.hg in glibmm-2.4:

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

Esta macro crea un constructor predeterminado sin argumentos.

Esta macro crea un constructor con argumentos, equivalente a una función de C *_new(). En realidad no llamará a la función *_new(), sino que simplemente creará un constructor equivalente con los mismos tipos de argumentos. Toma una firma de constructor de C++ y un nombre de función de C.

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_INTERFACE and _CLASS_OPAQUE_COPYABLE.

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

Suppresses definition of destructor in _CLASS_GOBJECT and _CLASS_GTKOBJECT.

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

Por ejemplo:

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.

Esta macro genera el método de C++ para envolver una función de C.

_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)

La función de C (por ejemplo, gtk_entry_set_text) se describe en mayor detalle en el archivo .defs, y los archivos convert*.m4 contienen la conversión necesaria del tipo de parámetro de C++ al tipo de C. Esta macro también genera comentarios de documentación de Doxygen basados en los archivos *_docs.xml y *_docs_override.xml.

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:

Esta macro es similar a _WRAP_METHOD(), pero sólo genera la documentación de un método de C++ que envuelve una función de C. Úsela cuando debe escribir el método a mano, pero quiere usar la documentación que se crearía si el método se generara.

_WRAP_METHOD_DOCS_ONLY(C function name)

For instance, from recentinfo.hg:

_WRAP_METHOD_DOCS_ONLY(gtk_recent_info_get_applications)

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() or _IGNORE_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)

Esta macro genera la señal de C++ con el estilo de libsigc++ para envolver una señal GObject de C. En realidad genera un método de acceso público, como signal_clicked(), que devuelve un objeto sustituto. gmmproc usa el archivo .defs para descubrir los tipos de parámetro de C y los archivos de conversión .m4 para descubrir conversiones de tipo adecuadas.

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

For instance, from button.hg:

_WRAP_SIGNAL(void clicked(),"clicked")

Las señales generalmente tienen punteros de funciones en la estructura de GTK, con un valor de enum correspondiente y un g_signal_new() en el archivo .c.

There are some optional extra arguments:

Esta macro genera el método de C++ que envuelve una propiedad GObject de C. Debe especificar el nombre de la propiedad y el tipo de C++ que quiere para la propiedad. gmmproc usa el archivo .defs para descubrir el tipo de C y el archivo de conversión .m4 para descubrir conversiones de tipo apropiadas.

_WRAP_PROPERTY(C property name, C++ type)

For instance, from button.hg:

_WRAP_PROPERTY("label", Glib::ustring)

There are some optional extra arguments:

Esta macro genera el método de C++ que envuelve una función virtual de C.

_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:

Una regla para la cual puede haber excepciones: si la función virtual de C devuelve un puntero a un objeto derivado de GObject, es decir un objeto cuyas referencias se cuentan, entonces la función virtual de C++ deberá devolver un objeto Glib::RefPtr<>. Se requiere uno de los argumentos adicionales refreturn o refreturn_ctype.

Esta macro genera código de inicialización para la interfaz.

_IMPLEMENTS_INTERFACE(C++ interface name)

For instance, from grid.hg:

_IMPLEMENTS_INTERFACE(Orientable)

There is one optional extra argument:

Esta macro genera una enum de C++ para envolver una enum de C. Debe especificar el nombre de C++ que quiere y el nombre de la enum de C subyacente.

For instance, from enums.hg:

_WRAP_ENUM(Orientation, GtkOrientation)

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 processes the same options (though NO_GTYPE, gtype_func <function_name> and CONV_TO_INT are ignored because they make 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.

Los métodos generados desde _WRAP_METHOD() podrán entonces lanzar esta excepción con la opción «errthrow».

For instance, from pixbuf.hg:

_WRAP_GERROR(PixbufError, GdkPixbufError, GDK_PIXBUF_ERROR)

_WRAP_GERROR() accepts the same optional arguments as _WRAP_ENUM() (though CONV_TO_INT is ignored because all exception class enums are plain enums within a class).

Use estas macros si está envolviendo una estructura simple o un tipo en caja que proporciona acceso directo a sus miembros de datos, para crear métodos de acceso y modificación para estos.

_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 estas macros para proporcionar métodos de acceso y modificación para un miembro de datos que es de tipo puntero automáticamente. Para la función de acceso, creará dos métodos, uno constante y otro no constante.

_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 estas macros para proporcionar métodos de acceso y modificación para un miembro de datos que es de tipo GObject que debe referenciarse antes de devolverse.

_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);

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

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

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);

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

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);

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

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

_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);

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

_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 macros is