Index

Package: Object

Description

package Glib.Object is

This package provides a minimal binding to the GObject type in Glib.

See Glib.Properties for information on how to manipulate properties

Packages

User_Data (generic)

Object_List (new Glib.GSlist.Generic_SList)

package Object_List is new Glib.GSlist.Generic_SList (GObject);

Object_Simple_List (new Glib.Glist.Generic_List)

package Object_Simple_List is new Glib.Glist.Generic_List (GObject);

User_Data_Closure (generic)

Classes

GObject_Record

type GObject_Record is tagged private;

Immediate Children:

Primitive operations:

Types

GObject

type GObject is access all GObject_Record'Class;

Weak_Notify

type Weak_Notify is access procedure
     (Data                 : System.Address;
      Where_The_Object_Was : System.Address);

Signal_Id_Array

type Signal_Id_Array is array (Guint range <>) of Glib.Signal_Id;

Signal_Query

type Signal_Query is private;

Interface_Vtable

type Interface_Vtable is private;
The virtual table of an interface (see Glib.Types). This is only useful when doing introspection.

GObject_Class

type GObject_Class is new GType_Class;

Ada_GObject_Class

type Ada_GObject_Class is record
      The_Type     : GType := 0;
   end record;

Signal_Parameter_Types

type Signal_Parameter_Types is
     array (Natural range <>, Natural range <>) of GType;
The description of the parameters for each event. These are the parameters that the application must provide when emitting the signal. The user can of course add his own parameters when connecting the signal in his application, through the use of Gtk.Handlers.User_Callback. Each event defined with Initialize_Class_Record below should have an entry in this table. If Gtk_Type_None is found in the table, it is ignored. For instance, a Signal_Parameter_Type like: (1 => (1 => Gdk_Type_Gdk_Event, 2 => GType_None), 2 => (1 => GType_Int, 2 => GType_Int)); defines two signals, the first with a single Gdk_Event parameter, the second with two ints parameters.

GInterfaceInitFunc

type GInterfaceInitFunc is access procedure
      (Iface : System.Address;
       Data  : System.Address);

GInterfaceFinalizeFunc

type GInterfaceFinalizeFunc is access procedure
      (Iface : System.Address;
       Data  : System.Address);

GInterface_Info

type GInterface_Info is record
      Interface_Init     : GInterfaceInitFunc := null;
      Interface_Finalize : GInterfaceFinalizeFunc := null;
      Interface_Data     : System.Address := System.Null_Address;
   end record;

Constants & Global variables

Null_GObject_Class (GObject_Class)

Null_GObject_Class : constant GObject_Class;

Uninitialized_Class (Ada_GObject_Class)

Uninitialized_Class : constant Ada_GObject_Class;
This type encloses all the informations related to a specific type of object or widget. All instances of such an object have a pointer to this structure, that includes the definition of all the signals that exist for a given object, all its properties,... A GObject_Class can be retrieved from an Ada_GObject_Class by calling Glib.Types.Class_Ref.

Null_Parameter_Types (Signal_Parameter_Types)

Null_Parameter_Types : constant Signal_Parameter_Types (1 .. 0, 1 .. 0) :=
     (others => (others => GType_None));
An empty array, used as a default parameter in Initialize_Class_Record.

Subprograms & Entries

Is_Created

function Is_Created 
(Object: GObject_Record'Class) return Boolean;
Return True if the associated C object has been created, False if no C object is associated with Object. This is not the same as testing whether an access type (for instance any of the widgets) is "null", since this relates to the underlying C object.

Get_Type

function Get_Type 
(Object: access GObject_Record) return GType;
Return the type of Object. This function is mostly used internally, since in Ada you can simply test whether an object belong to a class with a statement like: if Object in Gtk_Button_Record'Class then ... which is easier.

Initialize

procedure Initialize 
(Object: access GObject_Record'Class);
Internal initialization function. See the section "Creating your own widgets" in the documentation.

Ref

procedure Ref 
(Object: access GObject_Record);
Increment the reference counter for Object. See Unref below. Since an object is not deleted while its reference count is not null, this is a way to keep an object in memory, in particular when you want to temporarily remove a widget from its parent.

Unref

procedure Unref 
(Object: access GObject_Record);
Decrement the reference counter for Object. When this reaches 0, the object is effectively destroy, all the callbacks associated with it are disconnected.

Weak_Ref

procedure Weak_Ref 
(Object: access GObject_Record'Class;
Notify: Weak_Notify;
Data: System.Address := System.Null_Address);
This kind of reference doesn't increment the object's reference counting. However, it can and should be used to monitor the object's life cycle, in particular to detect is destruction. When Object is destroyed, calls Notify

Weak_Unref

procedure Weak_Unref 
(Object: access GObject_Record'Class;
Notify: Weak_Notify;
Data: System.Address := System.Null_Address);
Cancels the settings of Weak_Ref.

Deallocate

procedure Deallocate 
(Object: access GObject_Record);
This operation is used to deallocate Object. The default implementation assumes that the value passed in is an access value created by an allocator of the default pool, i.e. it will assume that an instance of Unchecked_Deallocation (GObject_Record'Class, GObject) can be used to deallocate the designated object. Types derived of GObject_Record can override this operation in order to cope with objects allocated on other pools or even objects allocated on the stack. This design is limited to support only one allocation strategy for each class, as the class tag is used to identify the applicable strategy.

Ref_Sink

procedure Ref_Sink 
(Object: access GObject_Record);
Increase the reference count of Object, and possibly remove the floating reference, if Object has a floating reference. In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.

Get_Object

function Get_Object 
(Object: access GObject_Record'Class) return System.Address;
Access the underlying C pointer.

Get_Object_Or_Null

function Get_Object_Or_Null 
(Object: GObject) return System.Address;
Same as above, but passing "null" is valid.

Set_Object

procedure Set_Object 
(Object: access GObject_Record'Class;
Value: System.Address);
Modify the underlying C pointer.

Get_User_Data

function Get_User_Data 
(Obj: System.Address;
Stub: GObject_Record'Class) return GObject;
Return the Ada object matching the C object Obj. If Obj was created explicitely from GtkAda, this will be the exact same widget. If Obj was created implicitely by gtk+ (buttons in complex windows,...), a new Ada object of type Stub will be created.

Get_User_Data_Fast

function Get_User_Data_Fast 
(Obj: System.Address;
Stub: GObject_Record'Class) return GObject;
Same as Get_User_Data, but does not try to guess the type of Obj, always default to Stub if Obj is unknown to GtkAda.

Unchecked_Cast

function Unchecked_Cast 
(Obj: access GObject_Record'Class;
Stub: GObject_Record'Class) return GObject;
Cast Obj in an object of tag Stub'Class. Return the resulting object and free the memory pointed by Obj.

Lookup

function Lookup 
(Object: Glib.GType;
Signal: String) return Glib.Signal_Id;
Returns the signal Id associated with a specific Object/Signal pair. Null_Signal_Id is returned if no such signal exists for Object. You can then use the Query procedure to get more information on the signal.

List_Ids

function List_Ids 
(Typ: Glib.GType) return Signal_Id_Array;
Return the list of signals defined for Typ. You can get more information on each of this signals by using the Query function below. See also the function Get_Type above to convert from an object instance to its type. Using a GType as the parameter makes it easier to find the signals for a widget and its ancestors (using Glib.Parent).

Query

procedure Query 
(Id: Glib.Signal_Id;
Result: out Signal_Query);
Return the description associated with the signal Id. You can get the various fields from Query with one of the functions below. Result is undefined if Id is Invalid_Signal_Id or Null_Signal_Id

Id

function Id 
(Q: Signal_Query) return Glib.Signal_Id;
Return the signal Id. Each Id is specific to a widget/signal name pair. These Ids can then be used to temporarily block a signal for instance, through the subprograms in Gtk.Handlers.

Signal_Name

function Signal_Name 
(Q: Signal_Query) return Glib.Signal_Name;
Return the name of the signal, as should be used in a call to Connect.

Return_Type

function Return_Type 
(Q: Signal_Query) return Glib.GType;
Return the type of object returned by the handlers for this signal.

Params

function Params 
(Q: Signal_Query) return GType_Array;
Return the list of parameters for the handlers for this signal

Initialize_Class_Record

procedure Initialize_Class_Record 
(Ancestor: GType;
Class_Record: in out Ada_GObject_Class;
Type_Name: String;
Signals: Gtkada.Types.Chars_Ptr_Array := No_Signals;
Parameters: Signal_Parameter_Types := Null_Parameter_Types);

Initialize_Class_Record

function Initialize_Class_Record 
(Ancestor: GType;
Class_Record: not null access Ada_GObject_Class;
Type_Name: String;
Signals: Gtkada.Types.Chars_Ptr_Array := No_Signals;
Parameters: Signal_Parameter_Types := Null_Parameter_Types) return Boolean;
Create the class record for a new object type. It is associated with Signals new signals. A pointer to the newly created structure is also returned in Class_Record. If Class_Record /= Uninitialized_Class, no memory allocation is performed, we just reuse it. As a result, each instantiation of an object will share the same GObject_Class, exactly as is done for gtk+. As a special case, if Parameters has its default value, all signals are created with no argument. This is done for backward compatibility mainly, and you should instead give it an explicit value. Type_Name should be a unique name identifying the name of the new type. Only the signals with no parameter can be connected from C code. However, any signal can be connected from Ada. This is due to the way we define default marshallers for the signals. The function returns True if the class record was just created (i.e. only the first time). This can be used to do further initialization at that point, like calling Gtk.Widget.Set_Default_Draw_Handler.

Type_From_Class

function Type_From_Class 
(Class_Record: GObject_Class) return GType;
Return the internal gtk+ type that describes the newly created Class_Record. See the function Glib.Types.Class_Peek for the opposite function converting from a GType to a GObject_Class.

G_New

procedure G_New 
(Object: not null access GObject_Record'Class;
Typ: GType);

G_New

procedure G_New 
(Object: not null access GObject_Record'Class;
Typ: Ada_GObject_Class);
Create a new instance of Typ (at the C level). This has no effect if the C object has already been created (so that G_New can be called from Initialize (and you can call the parent's Initialize). Object must have been allocated first, but you should not have called any of the Gtk_New procedures yet. This procedure is meant to be used when you create your own object types with own signals, properties,... The code would thus be Klass : aliased Ada_GObject_Class := Uninitialized_Class; function Get_Type return GType is begin if Initialize_Class_Record (Ancestor => Gtk.Button.Get_Type, Class_Record => Klass'Access, Type_Name => "My_Widget") begin -- Add interfaces if needed Add_Interface (Klass, ..., new GInterface_Info'(...)); -- Override the inherited methods Gtk.Widget.Set_Default_Draw_Handler (...); -- Install properties Install_Style_Property (Glib.Types.Class_Ref (Klass), Gnew_Int (...)); end if; return Klass.The_Type; end Get_Type; procedure Gtk_New (Self : out My_Widget) is begin Self := new My_Widget_Record; -- create the Ada wrapper Initialize (Self); end Gtk_New; procedure Initialize (Self : not null access My_Widget_Record'Class) is begin G_New (Self, Get_Type); -- allocate the C widget, unless done -- Initialize parent fields My_Widget_Parent.Initialize (Self); -- Initialization of the Ada types ... end Initialize;

Add_Interface

procedure Add_Interface 
(Klass: Ada_GObject_Class;
Iface: GType;
Info: not null access GInterface_Info);
State that Klass implements the given interface. It will need to override the inherited methods. This is low-level handling. Info should be allocated in this call, and is never freed in the lifetime of the application.

Interface_List_Properties

function Interface_List_Properties 
(Vtable: Interface_Vtable) return Glib.Param_Spec_Array;
Return the list of properties of an interface (see also Glib.Properties) from a Vtable from Default_Interface_Peek). See also Class_List_Properties for a similar function for objects.

Class_List_Properties

function Class_List_Properties 
(Class: GObject_Class) return Glib.Param_Spec_Array;
Return the list of all properties of the class.

Notify

procedure Notify 
(Object: access GObject_Record;
Property_Name: String);
Emits the "notify" signal, to signal every listener that the property has been changed.

Convert

function Convert 
(W: GObject) return System.Address;

Convert

function Convert 
(W: System.Address) return GObject;