This package provides a minimal binding to the GObject type in Glib. See Glib.Properties for information on how to manipulate properties
Signals |
---|
Types |
---|
type GObject_Class is private; | |
| |
type Signal_Id_Array is array (Guint range <>) of Glib.Signal_Id; | |
| |
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.
| |
type Signal_Query is private; | |
| |
type Weak_Notify is access procedure | |
|
Subprograms |
---|
function Is_Created (Object : in GObject_Record'Class) return Boolean; | ||
Return True if the associated C object has been created, False if | ||
function Get_Type (Object : access GObject_Record) return GType; | ||
Return the type of Object. if Object in Gtk_Button_Record'Class then ...
which is easier.
| ||
Life cycle | ||
procedure G_New (Object : out GObject); | ||
Create a new GObject. | ||
procedure Ref (Object : access GObject_Record); | ||
Increment the reference counter for Object. See Unref below. | ||
procedure Unref (Object : access GObject_Record); | ||
Decrement the reference counter for Object. When this reaches 0, the | ||
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 | ||
procedure Weak_Unref (Object : access GObject_Record'Class; Notify : Weak_Notify; Data : System.Address := System.Null_Address); | ||
Cancels the settings of Weak_Ref.
| ||
Interfacing with C | ||
The following functions are made public so that one can easily create | ||
function Get_Object (Object : access GObject_Record'Class) return System.Address; | ||
Access the underlying C pointer.
| ||
procedure Set_Object (Object : access GObject_Record'Class; Value : System.Address); | ||
Modify the underlying C pointer.
| ||
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 | ||
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, | ||
function Unchecked_Cast (Obj : access GObject_Record'Class; Stub : GObject_Record'Class) return GObject; | ||
Cast Obj in an object of tag Stub'Class. | ||
Signals | ||
Any child of GObject can be associated with any number of signals. The | ||
function Lookup (Object : Glib.GType; Signal : String) return Glib.Signal_Id; | ||
Returns the signal Id associated with a specific Object/Signal pair. | ||
function List_Ids (Typ : Glib.GType) return Signal_Id_Array; | ||
Return the list of signals defined for Typ. You can get more information | ||
procedure Query (Id : Glib.Signal_Id; Result : out Signal_Query); | ||
Return the description associated with the signal Id. You can get the | ||
function Id (Q : Signal_Query) return Glib.Signal_Id; | ||
Return the signal Id. Each Id is specific to a widget/signal name pair. | ||
function Signal_Name (Q : Signal_Query) return String; | ||
Return the name of the signal, as should be used in a call to Connect.
| ||
function Return_Type (Q : Signal_Query) return Glib.GType; | ||
Return the type of object returned by the handlers for this signal.
| ||
function Params (Q : Signal_Query) return GType_Array; | ||
Return the list of parameters for the handlers for this signal
| ||
Creating new widgets | ||
These types and functions are used only when creating new widget types | ||
procedure Initialize_Class_Record (Object : access GObject_Record'Class; Signals : Gtkada.Types.Chars_Ptr_Array; Class_Record : in out GObject_Class; Type_Name : String; Parameters : Signal_Parameter_Types := Null_Parameter_Types); | ||
Create the class record for a new object type. Note: The underlying C object must already have been initialized by a call to its parent's Initialize function. Parameters'Length should be the same as Signals'Length, or the result is undefined. 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.
| ||
function Type_From_Class (Class_Record : GObject_Class) return GType; | ||
Return the internal gtk+ type that describes the newly created | ||
function Class_From_Type (Typ : GType) return GObject_Class; | ||
Return the class record for a specific type
| ||
Signals | ||
??? This section is incomplete.
| ||
procedure Notify (Object : access GObject_Record; Property_Name : String); | ||
Emits the "notify" signal, to signal every listener that the property | ||
Lists | ||
function Convert (W : GObject) return System.Address; | ||
| ||
function C_Signal_Query_Size return Natural; | ||
|