----------------------------------------------------------------------- -- GtkAda - Ada95 binding for Gtk+/Gnome -- -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2010, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or -- -- modify it under the terms of the GNU 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 -- -- General Public License for more details. -- -- -- -- You should have received a copy of the GNU General Public -- -- License along with this library; if not, write to the -- -- Free Software Foundation, Inc., 59 Temple Place - Suite 330, -- -- Boston, MA 02111-1307, USA. -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----------------------------------------------------------------------- -- -- -- This package provides definitions for the basic types used in Glib, Cairo, -- Gdk and Gtk. -- -- -- Glib, the general-purpose library with Ada.Unchecked_Deallocation; with Ada.Unchecked_Conversion; with System; with Interfaces.C; package Glib is pragma Preelaborate; package C renames Interfaces.C; use type C.int; use type C.unsigned; ------------------------------------- -- The basic types defined by glib -- ------------------------------------- type Gshort is new C.short; type Glong is new C.long; type Gint is new C.int; type Gchar is new C.char; type Gboolean is new Gint; type Gushort is new C.unsigned_short; type Gulong is new C.unsigned_long; type Guint is new C.unsigned; type Guchar is new C.unsigned_char; type Gfloat is new C.C_float; type Gdouble is new C.double; type Gint8 is range -(2 ** 7) .. (2 ** 7 - 1); type Gint16 is range -(2 ** 15) .. (2 ** 15 - 1); type Gint32 is range -(2 ** 31) .. (2 ** 31 - 1); type Gint64 is range -(2 ** 63) .. (2 ** 63 - 1); type Guint8 is mod 2 ** 8; type Guint16 is mod 2 ** 16; type Guint32 is mod 2 ** 32; type Guint64 is mod 2 ** 64; type Gsize is new C.size_t; type Gunichar is new Guint32; subtype UTF8_String is String; -- A string that accepts only valid UTF8 sequences. -- Most Gtk+ function expect valid UTF8 strings instead of regular strings. type GTime_Val is record TV_Sec : Glong; TV_Usec : Glong; end record; pragma Convention (C, GTime_Val); type GTime_Val_Access is access all GTime_Val; pragma Convention (C, GTime_Val_Access); subtype Grange_Float is Gdouble; -- Needed for better compatibility between GtkAda 1.2 and 2.0 subtype Gcolor_Int is Guint16; -- Provided for better compatibility between GtkAda 1.2 and 2.0 subtype Allocation_Int is Gint; -- Provided for better compatibility between GtkAda 1.2 and 2.0 ---------------------- -- Some Array types -- ---------------------- type Gboolean_Array is array (Natural range <>) of Gboolean; type Gshort_Array is array (Natural range <>) of Gshort; type Glong_Array is array (Natural range <>) of Glong; type Gint_Array is array (Natural range <>) of Gint; type Guint_Array is array (Natural range <>) of Guint; type Guint32_Array is array (Natural range <>) of Guint32; type Gushort_Array is array (Natural range <>) of Gushort; type Gulong_Array is array (Natural range <>) of Gulong; type Gfloat_Array is array (Natural range <>) of Gfloat; type Guchar_Array is array (Natural range <>) of Guchar; type Gdouble_Array is array (Natural range <>) of Gdouble; type Boolean_Array is array (Natural range <>) of Boolean; type Short_Array is array (Natural range <>) of C.short; type Long_Array is array (Natural range <>) of C.long; ------------------------- -- Conversion services -- ------------------------- function To_Boolean_Array (A : Gboolean_Array) return Boolean_Array; -- Convert a C-style boolean array into an Ada-style array. function To_Gint (Bool : Boolean) return Gint; -- Convert an Ada boolean into a C int. ----------------------- -- Some Access types -- ----------------------- type Guchar_Array_Access is access Guchar_Array; type String_Ptr is access all String; -- procedure Free is new Ada.Unchecked_Deallocation (Object => Guchar_Array, Name => Guchar_Array_Access); procedure Free is new Ada.Unchecked_Deallocation (Object => String, Name => String_Ptr); -- -- type C_Dummy is limited private; -- type C_Proxy is access all C_Dummy; -- General proxy for C structures. -- This type is used instead of System.Address so that the variables are -- automatically initialized to 'null'. -- The value pointed to is irrelevant, and in fact should not be accessed. -- It has thus been made limited private with no subprogram to access it. -- C_Proxy is a public type so that one can compare directly the value -- of the variables with 'null'. -- pragma Convention (C, C_Proxy); function To_Proxy is new Ada.Unchecked_Conversion (System.Address, C_Proxy); function To_Address is new Ada.Unchecked_Conversion (C_Proxy, System.Address); -- Converts from a System.Address returned by a C function to an -- internal C_Proxy. -- type G_Destroy_Notify_Address is access procedure (Data : System.Address); pragma Convention (C, G_Destroy_Notify_Address); type G_Destroy_Notify is access procedure (Data : Glib.C_Proxy); pragma Convention (C, G_Destroy_Notify); -- Callback used when some named data associated with an object is -- destroyed. ------------ -- Quarks -- ------------ type GQuark is new Guint32; -- Represents a string internally in GtkAda. Once you know the -- equivalent for a string, you can always use it instead of the string, -- which provides a faster access for all the functions that use htables -- in GtkAda. -- There is a global htable that contains all the quarks defined in -- your application and GtkAda itself. Unknown_Quark : constant GQuark := 0; function Quark_From_String (Id : String) return GQuark; -- Return, or create the quark associated with the string. -- Note that if the quark does not already exist, an entry is created for -- it in the global htable for quarks. function Quark_Try_String (Id : String) return GQuark; -- Return the quark associated with the string, if it exists. -- If it does not exist, return Unknown_Quark. ------------- -- Signals -- ------------- type Signal_Id is private; -- This uniquely identifies a connection widget<->signal. type Signal_Name is new String; -- A signal name as used in connect, shared type between the Gtk -- and Glib layer. Invalid_Signal_Id : constant Signal_Id; Null_Signal_Id : constant Signal_Id; type G_Connect_Flags is mod 2 ** C.int'Size; G_Connect_After : constant G_Connect_Flags := 2 ** 0; G_Connect_Swapped : constant G_Connect_Flags := 2 ** 1; -- Used to specify the behavior of a signal's connection. ---------------- -- Properties -- ---------------- -- This is only the definition of the property types. See Glib.Properties -- on how to get and set the value of properties for specific objects, or -- the package Glib.Properties.Creation for information on how to create -- new properties in your own widgets. -- Introspection is available, ie from an existing object you can find out -- the list of properties it supports. See the functions -- Glib.Object.Interface_List_Properties and -- Glib.Object.Class_List_Properties type Property (<>) is private; function Build (Name : String) return Property; -- You should use this function only if you are creating new widgets, and -- their properties. Normal usage of properties doesn't require the use -- of this function. -- An ASCII.NUL character is automatically appended if necessary function Property_Name (Prop : Property) return String; -- Return the name of the property. -- This name includes the trailing ASCII.Nul, and thus can be passed as is -- to C. type Param_Spec is new Glib.C_Proxy; type Param_Spec_Array is array (Natural range <>) of Param_Spec; -- See Glib.Properties.Creation for more information on this type type Param_Flags is mod 2 ** 6; Param_Readable : constant Param_Flags := 2 ** 0; Param_Writable : constant Param_Flags := 2 ** 1; Param_Construct : constant Param_Flags := 2 ** 2; Param_Construct_Only : constant Param_Flags := 2 ** 3; Param_Lax_Validation : constant Param_Flags := 2 ** 4; Param_Private : constant Param_Flags := 2 ** 5; -- These are the various flags that help define if, and when, a property -- can be read and modified. ----------- -- GType -- ----------- type GType is new Gsize; -- This type describes an internal type in Glib. -- You shouldn't have to use it in your own applications, however it might -- be useful sometimes. -- Every object type is associated with a specific value, created -- dynamically at run time the first time you instantiate an object of that -- type (thus if you have never used e.g a Gtk_File_Selection, it won't -- have any GType associated with it). -- You can get the exact type value for each type by using the functions -- Get_Type provided in all the packages in GtkAda. -- You can get the specific value for an existing widget by using the -- function Glib.Object.Get_Type. type GType_Class is private; -- An opaque structure used as the base for all classes in glib and gtk+. -- See also Glib.Object.GObject_Class for a more useful child of this -- type. type GType_Array is array (Guint range <>) of Glib.GType; function Parent (Typ : GType) return GType; -- Return the parent type of Typ (eg if Typ is associated with a Gtk -- widget, it returns the typ of its parent). function Fundamental (Typ : GType) return GType; -- Return the fundamental type for Type. In gtk+, the types are organized -- into several hierarchies, similar to what is done for widgets. -- All of these hierarchies are based on one of the fundamental types -- defined below. -- This function returns that fundamental type. -- -- For instance, each enumeration type in gtk+ has its own GType. -- However, Fundamental will return GType_Enum in all of these cases. function Type_Name (Type_Num : GType) return String; -- Return the name of the type (enumeration,...) associated with Typ. -- If Fundamental (Typ) return GType_Enum, this returns the name of -- the enumeration type that Typ represents. -- This might be useful in debug messages. function Type_From_Name (Name : String) return GType; -- Convert a string to the matching type. -- Name should be the C GObject name rather than the Ada name: thus, -- use names such as GtkScrollbar or GtkButton for widgets. function Get_Qdata (Typ : GType; Quark : GQuark) return Glib.C_Proxy; -- Return the user data set for Typ procedure Set_Qdata (Typ : GType; Quark : GQuark; Data : Glib.C_Proxy); -- Associate some named data with Typ. -- The list of fundamental types defined in Glib. As opposed to most other -- types (for instance the ones used for widgets), the types have static -- values, always the same. GType_Fundamental_Shift : constant Integer := 2; GType_Invalid : constant GType := 0 * (2 ** GType_Fundamental_Shift); GType_None : constant GType := 1 * (2 ** GType_Fundamental_Shift); GType_Interface : constant GType := 2 * (2 ** GType_Fundamental_Shift); GType_Char : constant GType := 3 * (2 ** GType_Fundamental_Shift); GType_Uchar : constant GType := 4 * (2 ** GType_Fundamental_Shift); GType_Boolean : constant GType := 5 * (2 ** GType_Fundamental_Shift); GType_Int : constant GType := 6 * (2 ** GType_Fundamental_Shift); GType_Uint : constant GType := 7 * (2 ** GType_Fundamental_Shift); GType_Long : constant GType := 8 * (2 ** GType_Fundamental_Shift); GType_Ulong : constant GType := 9 * (2 ** GType_Fundamental_Shift); GType_Int64 : constant GType := 10 * (2 ** GType_Fundamental_Shift); GType_UInt64 : constant GType := 11 * (2 ** GType_Fundamental_Shift); GType_Enum : constant GType := 12 * (2 ** GType_Fundamental_Shift); GType_Flags : constant GType := 13 * (2 ** GType_Fundamental_Shift); GType_Float : constant GType := 14 * (2 ** GType_Fundamental_Shift); GType_Double : constant GType := 15 * (2 ** GType_Fundamental_Shift); GType_String : constant GType := 16 * (2 ** GType_Fundamental_Shift); -- Null terminated string. GType_Pointer : constant GType := 17 * (2 ** GType_Fundamental_Shift); -- A general pointer type. GType_Param : constant GType := 19 * (2 ** GType_Fundamental_Shift); GType_Object : constant GType := 20 * (2 ** GType_Fundamental_Shift); -- One of the widgets/objects ----------------- -- Boxed types -- ----------------- -- Boxed types are a convenient way to encapsulate Ada types through a C -- layer. An initialization and a finalization function can be provided. -- The most frequent usage of such types is in argument to signals and -- handlers (See the functions in Glib.Values), or to store such types -- in a Gtk_Tree_Model. This allows you for instance to store reference -- counted types where you want to be able to control what should happen -- when the cell is removed from the tree. -- -- See an example with the subprogram Glib.Values.Set_Boxed GType_Boxed : constant GType := 18 * (2 ** GType_Fundamental_Shift); -- The base type for all boxed types. In tree models, you should use the -- actual type returned by Boxed_Type_Register_Static. type Boxed_Copy is access function (Boxed : System.Address) return System.Address; pragma Convention (C, Boxed_Copy); type Boxed_Free is access procedure (Boxed : System.Address); pragma Convention (C, Boxed_Free); function Boxed_Type_Register_Static (Name : String; Copy : Boxed_Copy; Free : Boxed_Free) return GType; -- Create a new boxed type private type C_Dummy is record Dummy1 : System.Address; end record; pragma Convention (C, C_Dummy); -- This array can contain anything, since it is never used on the Ada side -- anyway. Pretend it contains an address so that the compiler a -- reasonable default alignment, compatible with most types. type GType_Class is new System.Address; type Property is new String; type Signal_Id is new Guint; Invalid_Signal_Id : constant Signal_Id := -1; Null_Signal_Id : constant Signal_Id := 0; pragma Import (C, Fundamental, "ada_gtype_fundamental"); pragma Import (C, Parent, "g_type_parent"); pragma Import (C, Get_Qdata, "g_type_get_qdata"); pragma Import (C, Set_Qdata, "g_type_set_qdata"); pragma Inline (Build); end Glib;