## Documentation

Table of Contents
Class Inheritance Tree
Widget Screenshots
Package groups

1.     -----------------------------------------------------------------------

2.     --               GtkAda - Ada95 binding for Gtk+/Gnome               --

3.     --                                                                   --

4.     --                   Copyright (C) 2001 ACT-Europe                   --

5.     --                                                                   --

6.     -- This library is free software; you can redistribute it and/or     --

7.     -- modify it under the terms of the GNU General Public               --

8.     -- License as published by the Free Software Foundation; either      --

9.     -- version 2 of the License, or (at your option) any later version.  --

10.     --                                                                   --

11.     -- This library is distributed in the hope that it will be useful,   --

12.     -- but WITHOUT ANY WARRANTY; without even the implied warranty of    --

13.     -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU --

14.     -- General Public License for more details.                          --

15.     --                                                                   --

16.     -- You should have received a copy of the GNU General Public         --

17.     -- License along with this library; if not, write to the             --

18.     -- Free Software Foundation, Inc., 59 Temple Place - Suite 330,      --

19.     -- Boston, MA 02111-1307, USA.                                       --

20.     --                                                                   --

21.     -- As a special exception, if other files instantiate generics from  --

22.     -- this unit, or you link this unit with other files to produce an   --

23.     -- executable, this  unit  does not  by itself cause  the resulting  --

24.     -- executable to be covered by the GNU General Public License. This  --

25.     -- exception does not however invalidate any other reasons why the   --

26.     -- executable file  might be covered by the  GNU Public License.     --

27.     -----------------------------------------------------------------------

29.     --  <description>

30.     --

31.     --  This package provides all the required subprograms to create and

32.     --  manipulate new properties associated with new widget types.

33.     --

34.     --  You do not have to be familiar with this package in order to use

35.     --  properties. See Glib.Object instead, that provides the minimal

36.     --  subprograms to get and set properties.

37.     --

38.     --  This package is only intended for writers of new widgets. You will need

39.     --  this function to create new properties.

40.     --

41.     --  Each object in gtk+ has a set of so-called properties. These are

42.     --  attributes that can be accessed, and possibly modified, by names.

43.     --  They provide introspection, that is an object can specify which

44.     --  properties it knows about, which can be modified,..., and thus provide a

45.     --  huge support for special applications like GUI-Builders that need to act

46.     --  on any kind of widgets, even those it doesn't know about yet.

47.     --

48.     --  However, for efficiency reasons, the properties are only names, and are

49.     --  not the only way to modify attributes of objects. It is often more

50.     --  efficient to use the alternate method, as documented in the GtkAda

51.     --  documentation for each property.

52.     --

53.     --  Another interesting feature of properties is that every time a property

54.     --  is modified, a signal "property_changed" or "notify" is emitted, and

55.     --  it is thus easy to keep track of attributes in objects.

56.     --

57.     --  </description>

58.     --  <group>Glib, the general-purpose library</group>

60.     with Glib.ObjectTo API docTo specTo body;

61.     with Glib.ValuesTo API docTo specTo body;

62.     with Interfaces.C.Strings;

64.     package Glib.Properties.CreationTo API docTo specTo body is

66.        --  subtype Param_Spec is Glib.Param_Spec;

68.        --  This type is the internal representation for properties. It contains all

69.        --  the required information about it, including some help string or the

70.        --  range of values it recognizes.

71.        --

72.        --  All the values contained in a param_spec are typed. However, since these

73.        --  are not implemented as tagged types, it is your responsability to

74.        --  convert the param_specs to the appropriate type, based on the value

75.        --  returned by Value_Type. Most of the time, you won't need to use these

76.        --  functions at all, unless you are programming some self-inspection

77.        --  application, like a GUI-Builder for instance, or creating new properties

78.        --  for a new widget.

80.        procedure UnrefTo API docTo body (Param : Param_SpecTo API docTo spec);

81.        --  Decrement the reference counter. If it reaches 0, the memory is freed.

83.        ------------------

84.        -- Enum classes --

85.        ------------------

86.        --  gtk+, a C library, has a whole system to describe its enumeration types,

87.        --  similar to what is available from the start in Ada ('Image and 'Value

88.        --  for instance). All enumerations are represented internally as

89.        --  Enum_Classes. However, there is no easy conversion between such an

90.        --  enum class and a GtkAda enumeration type.

91.        --  Most of the time, this has no impact on your work, since you know

92.        --  what type you need to use when calling an Ada function. However, you

93.        --  will need to manipulate these enumeration classes when interfacing

94.        --  with ParamSpecs and dealing with properties.

96.        type Enum_Class is new Glib.C_ProxyTo API docTo spec;

97.        type Enum_Value is new Glib.C_ProxyTo API docTo spec;

99.        function Get_ValueTo API docTo body (Klass : Enum_ClassTo API docTo spec; Value : Glib.GintTo API docTo spec)

100.           return Enum_ValueTo API docTo spec;

101.        --  Return the value in Klass that is Value (equivalent of 'Val in Ada)

103.        function Nth_ValueTo API docTo body (Klass : Enum_ClassTo API docTo spec; Nth : Glib.GuintTo API docTo spec) return Enum_ValueTo API docTo spec;

104.        --  Return the Nth-th value in Klass, or null if there is no such value.

106.        function ValueTo API docTo body (Val : Enum_ValueTo API docTo spec) return Glib.GintTo API docTo spec;

107.        --  Return the numeric value for a specific enumeration. Use the matching

108.        --  Ada type and 'Val to convert it to a valid Ada enumeration

110.        function NameTo API docTo body (Val : Enum_ValueTo API docTo spec) return String;

111.        --  Return the name of Val. This is the equivalent of 'Image in Ada.

113.        function NickTo API docTo body (Val : Enum_ValueTo API docTo spec) return String;

114.        --  Return a displayable string for Val.

116.        function Register_Static_EnumTo API docTo body

117.          (Name   : String;

118.           Values : Interfaces.C.Strings.chars_ptr_array) return Glib.GTypeTo API docTo spec;

119.        --  Create a new enumeration class from a list of valid values.

120.        --  Values must be freed by the caller.

122.        function Enum_Class_From_TypeTo API docTo body (Typ : Glib.GTypeTo API docTo spec) return Enum_ClassTo API docTo spec;

123.        --  Return the enumeration class corresponding to a type

125.        -------------------

126.        -- Flags classes --

127.        -------------------

128.        --  These are very similar to Enum Classes. However, the actual value

129.        --  of an instance of this type is a combination of a set of flags, rather

130.        --  than one single enumeration value.

131.        --  For instance, a Gdk_Event_Mask is a Flags_Class

133.        type Flags_Class is new Glib.C_ProxyTo API docTo spec;

134.        type Flags_Value is new Glib.C_ProxyTo API docTo spec;

135.        type Flags_Int_Value is mod Glib.GintTo API docTo spec'Last;

137.        function Nth_ValueTo API docTo body (Klass : Flags_ClassTo API docTo spec; Nth : Glib.GuintTo API docTo spec)

138.           return Flags_ValueTo API docTo spec;

139.        --  Return the Nth-th value in Klass, or null if there is no such value.

141.        function ValueTo API docTo body (Val : Flags_ValueTo API docTo spec) return Flags_Int_ValueTo API docTo spec;

142.        --  Return the numeric value for a specific enumeration. Use the matching

143.        --  Ada type and 'Val to convert it to a valid Ada enumeration

145.        function NameTo API docTo body (Val : Flags_ValueTo API docTo spec) return String;

146.        --  Return the name of Val. This is the equivalent of 'Image in Ada.

148.        function NickTo API docTo body (Val : Flags_ValueTo API docTo spec) return String;

149.        --  Return a displayable string for Val.

151.        ---------------

152.        -- ParamSpec --

153.        ---------------

155.        function Pspec_NameTo API docTo body (Param : Param_SpecTo API docTo spec) return String;

156.        --  Return the name of the property.

157.        --  This is the internal string representing the property. It

158.        --  Should probably not be displayed on

160.        function Nick_NameTo API docTo body (Param : Param_SpecTo API docTo spec) return String;

161.        --  Return the nickname of the property. This is a string

162.        --  that can be displayed to represent the property, and is

163.        --  more user-friendly than the result of Name.

165.        function FlagsTo API docTo body (Param : Param_SpecTo API docTo spec) return Param_FlagsTo API docTo spec;

166.        --  Return the flags for the property

168.        function Owner_TypeTo API docTo body (Param : Param_SpecTo API docTo spec) return Glib.GTypeTo API docTo spec;

169.        --  The type that defined Param. If you look for instance at all properties

170.        --  provides by a type, they will also include properties provided by the

171.        --  parents of the type. This function can be used to find those declared

172.        --  with that type only

174.        function DescriptionTo API docTo body (Param : Param_SpecTo API docTo spec) return String;

175.        --  Return the description (ie the help string) for Param

177.        function Value_TypeTo API docTo body (Param : Param_SpecTo API docTo spec) return Glib.GTypeTo API docTo spec;

178.        --  Return the type of param

180.        procedure Set_Value_TypeTo API docTo body (Param : Param_SpecTo API docTo spec; Typ : Glib.GTypeTo API docTo spec);

181.        --  Override the type of param. You should only use this function when

182.        --  creating new Param_Spec types based on existing types. You should not

183.        --  change the type if you haven't created param yourself.

185.        function Get_QdataTo API docTo body (Param : Param_SpecTo API docTo spec; Quark : GQuarkTo API docTo spec) return Glib.C_ProxyTo API docTo spec;

186.        --  Return the user data set for Param

188.        procedure Set_QdataTo API docTo body

189.          (Param   : Param_SpecTo API docTo spec;

190.           Quark   : GQuarkTo API docTo spec;

191.           Data    : Glib.C_ProxyTo API docTo spec;

192.           Destroy : G_Destroy_NotifyTo API docTo spec := null);

193.        --  Associate some named data with Param. Destroy is called when Param is

194.        --  destroyed.

196.        --  Value_Type returns GType_Char

197.        type Param_Spec_Char is new Param_SpecTo API docTo spec;

198.        function MinimumTo API docTo body (Param : Param_Spec_CharTo API docTo spec) return Glib.Gint8To API docTo spec;

199.        function MaximumTo API docTo body (Param : Param_Spec_CharTo API docTo spec) return Glib.Gint8To API docTo spec;

200.        function DefaultTo API docTo body (Param : Param_Spec_CharTo API docTo spec) return Glib.Gint8To API docTo spec;

201.        function Gnew_CharTo API docTo body

202.          (Name, Nick, Blurb         : String;

203.           Minimum, Maximum, Default : Glib.Gint8To API docTo spec;

204.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

205.           return Param_SpecTo API docTo spec;

207.        --  Value_Type returns GType_UChar

208.        type Param_Spec_Uchar is new Param_SpecTo API docTo spec;

209.        function MinimumTo API docTo body (Param : Param_Spec_UcharTo API docTo spec) return Glib.Guint8To API docTo spec;

210.        function MaximumTo API docTo body (Param : Param_Spec_UcharTo API docTo spec) return Glib.Guint8To API docTo spec;

211.        function DefaultTo API docTo body (Param : Param_Spec_UcharTo API docTo spec) return Glib.Guint8To API docTo spec;

212.        function Gnew_UcharTo API docTo body

213.          (Name, Nick, Blurb         : String;

214.           Minimum, Maximum, Default : Glib.Guint8To API docTo spec;

215.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

216.           return Param_SpecTo API docTo spec;

218.        --  Value_Type returns GType_Bool

219.        type Param_Spec_Boolean is new Param_SpecTo API docTo spec;

220.        function DefaultTo API docTo body (Param : Param_Spec_BooleanTo API docTo spec) return Boolean;

221.        function Gnew_BooleanTo API docTo body

222.          (Name, Nick, Blurb : String;

223.           Default           : Boolean;

224.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

225.           return Param_SpecTo API docTo spec;

227.        --  Value_Type returns GType_Int

228.        type Param_Spec_Int is new Param_SpecTo API docTo spec;

229.        function MinimumTo API docTo body (Param : Param_Spec_IntTo API docTo spec) return Glib.GintTo API docTo spec;

230.        function MaximumTo API docTo body (Param : Param_Spec_IntTo API docTo spec) return Glib.GintTo API docTo spec;

231.        function DefaultTo API docTo body (Param : Param_Spec_IntTo API docTo spec) return Glib.GintTo API docTo spec;

232.        function Gnew_IntTo API docTo body

233.          (Name, Nick, Blurb         : String;

234.           Minimum, Maximum, Default : Glib.GintTo API docTo spec;

235.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

236.           return Param_SpecTo API docTo spec;

238.        --  Value_Type returns GType_Uint

239.        type Param_Spec_Uint is new Param_SpecTo API docTo spec;

240.        function MinimumTo API docTo body (Param : Param_Spec_UintTo API docTo spec) return Glib.GuintTo API docTo spec;

241.        function MaximumTo API docTo body (Param : Param_Spec_UintTo API docTo spec) return Glib.GuintTo API docTo spec;

242.        function DefaultTo API docTo body (Param : Param_Spec_UintTo API docTo spec) return Glib.GuintTo API docTo spec;

243.        function Gnew_UintTo API docTo body

244.          (Name, Nick, Blurb         : String;

245.           Minimum, Maximum, Default : Glib.GuintTo API docTo spec;

246.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

247.           return Param_SpecTo API docTo spec;

249.        --  Value_Type returns GType_Long

250.        type Param_Spec_Long is new Param_SpecTo API docTo spec;

251.        function MinimumTo API docTo body (Param : Param_Spec_LongTo API docTo spec) return Glib.GlongTo API docTo spec;

252.        function MaximumTo API docTo body (Param : Param_Spec_LongTo API docTo spec) return Glib.GlongTo API docTo spec;

253.        function DefaultTo API docTo body (Param : Param_Spec_LongTo API docTo spec) return Glib.GlongTo API docTo spec;

254.        function Gnew_LongTo API docTo body

255.          (Name, Nick, Blurb         : String;

256.           Minimum, Maximum, Default : Glib.GlongTo API docTo spec;

257.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

258.           return Param_SpecTo API docTo spec;

260.        --  Value_Type returns GType_ULong

261.        type Param_Spec_Ulong is new Param_SpecTo API docTo spec;

262.        function MinimumTo API docTo body (Param : Param_Spec_UlongTo API docTo spec) return Glib.GulongTo API docTo spec;

263.        function MaximumTo API docTo body (Param : Param_Spec_UlongTo API docTo spec) return Glib.GulongTo API docTo spec;

264.        function DefaultTo API docTo body (Param : Param_Spec_UlongTo API docTo spec) return Glib.GulongTo API docTo spec;

265.        function Gnew_UlongTo API docTo body

266.          (Name, Nick, Blurb         : String;

267.           Minimum, Maximum, Default : Glib.GulongTo API docTo spec;

268.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

269.           return Param_SpecTo API docTo spec;

271.        --  Value_Type returns ???

272.        type Param_Spec_Unichar is new Param_SpecTo API docTo spec;

273.        function DefaultTo API docTo body (Param : Param_Spec_UnicharTo API docTo spec) return GunicharTo API docTo spec;

274.        function Gnew_UnicharTo API docTo body

275.          (Name, Nick, Blurb : String;

276.           Default           : GunicharTo API docTo spec;

277.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

278.           return Param_SpecTo API docTo spec;

280.        --  Value_Type returns GType_Enum

281.        --  See also the package Generic_Enumeration_Property on how to create

282.        --  properties based on an Ada enumeration type.

283.        type Param_Spec_Enum is new Param_SpecTo API docTo spec;

284.        function EnumerationTo API docTo body (Param : Param_Spec_EnumTo API docTo spec) return Enum_ClassTo API docTo spec;

285.        function DefaultTo API docTo body (Param : Param_Spec_EnumTo API docTo spec) return Glib.GintTo API docTo spec;

286.        function Gnew_EnumTo API docTo body

287.          (Name, Nick, Blurb : String;

288.           Enum_Type         : GTypeTo API docTo spec;

289.           Default           : GintTo API docTo spec := 0;

290.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

291.           return Param_SpecTo API docTo spec;

292.        --  See Glib.Properties.Creation.Register_Static_Enum on how to create

293.        --  Enum_Type

295.        --  Value_Type returns GType_Flags

296.        type Param_Spec_Flags is new Param_SpecTo API docTo spec;

297.        function Flags_EnumerationTo API docTo body (Param : Param_Spec_FlagsTo API docTo spec) return Flags_ClassTo API docTo spec;

298.        function DefaultTo API docTo body (Param : Param_Spec_FlagsTo API docTo spec) return GlongTo API docTo spec;

299.        function Gnew_FlagsTo API docTo body

300.          (Name, Nick, Blurb : String;

301.           Flags_Type        : Glib.GTypeTo API docTo spec;

302.           Default           : GuintTo API docTo spec;

303.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

304.           return Param_SpecTo API docTo spec;

306.        --  Value_Type returns GType_Float

307.        type Param_Spec_Float is new Param_SpecTo API docTo spec;

308.        function MinimumTo API docTo body (Param : Param_Spec_FloatTo API docTo spec) return GfloatTo API docTo spec;

309.        function MaximumTo API docTo body (Param : Param_Spec_FloatTo API docTo spec) return GfloatTo API docTo spec;

310.        function DefaultTo API docTo body (Param : Param_Spec_FloatTo API docTo spec) return GfloatTo API docTo spec;

311.        function EpsilonTo API docTo body (Param : Param_Spec_FloatTo API docTo spec) return GfloatTo API docTo spec;

312.        function Gnew_FloatTo API docTo body

313.          (Name, Nick, Blurb         : String;

314.           Minimum, Maximum, Default : Glib.GfloatTo API docTo spec;

315.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

316.           return Param_SpecTo API docTo spec;

318.        --  Value_Type returns GType_Double

319.        type Param_Spec_Double is new Param_SpecTo API docTo spec;

320.        function MinimumTo API docTo body (Param : Param_Spec_DoubleTo API docTo spec) return GdoubleTo API docTo spec;

321.        function MaximumTo API docTo body (Param : Param_Spec_DoubleTo API docTo spec) return GdoubleTo API docTo spec;

322.        function DefaultTo API docTo body (Param : Param_Spec_DoubleTo API docTo spec) return GdoubleTo API docTo spec;

323.        function EpsilonTo API docTo body (Param : Param_Spec_DoubleTo API docTo spec) return GdoubleTo API docTo spec;

324.        function Gnew_DoubleTo API docTo body

325.          (Name, Nick, Blurb         : String;

326.           Minimum, Maximum, Default : Glib.GdoubleTo API docTo spec;

327.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

328.           return Param_SpecTo API docTo spec;

330.        --  Value_Type returns GType_String

331.        type Param_Spec_String is new Param_SpecTo API docTo spec;

332.        function DefaultTo API docTo body (Param : Param_Spec_StringTo API docTo spec) return String;

333.        function Cset_FirstTo API docTo body (Param : Param_Spec_StringTo API docTo spec) return String;

334.        function Cset_NthTo API docTo body (Param : Param_Spec_StringTo API docTo spec) return String;

335.        function SubstitutorTo API docTo body (Param : Param_Spec_StringTo API docTo spec) return Character;

336.        function Ensure_Non_NullTo API docTo body (Param : Param_Spec_StringTo API docTo spec) return Boolean;

337.        function Gnew_StringTo API docTo body

338.          (Name, Nick, Blurb : String;

339.           Default           : String;

340.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

341.           return Param_SpecTo API docTo spec;

343.        --  Value_Type returns GType_Param

344.        type Param_Spec_Param is new Param_SpecTo API docTo spec;

345.        function Gnew_ParamTo API docTo body

346.          (Name, Nick, Blurb : String;

347.           Param_Type        : Glib.GTypeTo API docTo spec;

348.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

349.           return Param_SpecTo API docTo spec;

351.        --  Value_Type returns GType_Boxed

352.        type Param_Spec_Boxed is new Param_SpecTo API docTo spec;

353.        function Gnew_BoxedTo API docTo body

354.          (Name, Nick, Blurb : String;

355.           Boxed_Type        : Glib.GTypeTo API docTo spec;

356.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

357.           return Param_SpecTo API docTo spec;

359.        --  Value_Type returns GType_Pointer

360.        type Param_Spec_Pointer is new Param_SpecTo API docTo spec;

361.        function Gnew_PointerTo API docTo body

362.          (Name, Nick, Blurb : String;

363.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

364.           return Param_SpecTo API docTo spec;

366.        --  Value_Type returns GType_Param_Value_Array

367.        --  type Param_Spec_Value_Array is new Param_Spec;

369.        --  Value_Type returns GType_Object

370.        type Param_Spec_Object is new Param_SpecTo API docTo spec;

371.        function Gnew_ObjectTo API docTo body

372.          (Name, Nick, Blurb : String;

373.           Object_Type       : Glib.GTypeTo API docTo spec;

374.           Flags : Param_FlagsTo API docTo spec := Param_ReadableTo API docTo spec or Param_WritableTo API docTo spec)

375.           return Param_SpecTo API docTo spec;

377.        -----------------------------

378.        -- Creating new properties --

379.        -----------------------------

380.        --  There are several things that need to be done when creating a property.

381.        --  For one thing, you need to create the string that represents the

382.        --  property. This is the only item that needs to go in the specifications

383.        --  of your page.

384.        --  You then need to describe the type of the property, and the values it

385.        --  allows. This is very simple for simple types, and a generic packages is

386.        --  provided to handle the more complex enumeration-based properties.

387.        --

388.        --  Your widget needs to define two handlers, Set_Property_Handler and

389.        --  Get_Property_Handler, that are called every time the user accesses the

390.        --  value of a property through a call to Glib.Object.Set_Property or

391.        --  Glib.Object.Get_Property.

392.        --

393.        --  For efficiency reasons, a property is also associated with an integer

394.        --  value, that you must provide when creating the property. This value is

395.        --  completely free, and is passed to the two handlers described above.

396.        --

397.        --  The two handlers manipulate Glib.Values.GValue values, so that they

398.        --  can get and return various types.

400.        type Property_Id is new GuintTo API docTo spec;

402.        type Set_Property_Handler is access procedure

403.          (Object        : access Glib.Object.GObject_RecordTo API docTo specTo body'Class;

404.           Prop_Id       : Property_IdTo API docTo spec;

405.           Value         : Glib.Values.GValueTo API docTo specTo body;

406.           Property_Spec : Param_SpecTo API docTo spec);

407.        --  This handler is called every time the user has asked for a new

408.        --  property to be changed.

409.        --  Prop_Id is the id you used when creating the property.

410.        --  Value is the new value that should be set. It is your responsability

411.        --  to extract the actual value from it. However, consistency has already

412.        --  been checked by gtk+, so we know the type is correct.

413.        --  Property_Spec is the definition of the property.

414.        --

415.        --  Note: It is your responsability to emit the "notify" signal after a

416.        --  property has been modified. The recommended way is to emit this signal

417.        --  from the internal function that actually modified the property, not

418.        --  directly from the Set_Propert_Handler itself. This will ensure that

419.        --  even if the user doesn't modify the attribute through a property but

420.        --  directly by calling the lower-level subprogram, the signal will still

421.        --  be emitted.

423.        type Get_Property_Handler is access procedure

424.          (Object        : access Glib.Object.GObject_RecordTo API docTo specTo body'Class;

425.           Prop_Id       : Property_IdTo API docTo spec;

426.           Value         : out Glib.Values.GValueTo API docTo specTo body;

427.           Property_Spec : Param_SpecTo API docTo spec);

428.        --  This handler is called when the application needs to retrive the value

429.        --  of a property. You should set the value in Value

431.        procedure Set_Properties_HandlersTo API docTo body

432.          (Class_Record : Glib.Object.GObject_ClassTo API docTo spec;

433.           Set_Property : Set_Property_HandlerTo API docTo spec;

434.           Get_Property : Get_Property_HandlerTo API docTo spec);

435.        --  Set the two functions used to set and retrieve properties. You

436.        --  should never call this function on the class record of the standard

437.        --  gtk+ widgets, since this will break their behavior. You should first

438.        --  create a new class record through Initialize_Class_Record, and then

439.        --  use the returned Class_Record as a parameter to this subprogram.

440.        --

441.        --  You cannot pass null to either of the two parameters, or you won't

442.        --  be able to install new properties afterwards

444.        procedure Install_PropertyTo API docTo body

445.          (Class_Record  : Glib.Object.GObject_ClassTo API docTo spec;

446.           Prop_Id       : Property_IdTo API docTo spec;

447.           Property_Spec : Param_SpecTo API docTo spec);

448.        --  Adds a new property to Class_Record. You should use this function only

449.        --  on class records you have created yourself, not on one of the standard

450.        --  widgets.

451.        --  Prop_Id is the internal representation for properties, that will be

452.        --  passed to the Set_Property and Get_Property_Handlers (see above) to set

453.        --  and retrieve the value of a property.

454.        --  Property_Spec should be the result of one of the GNew_* subprograms for

455.        --  Param_Spec, and this defines the type of the property.

457.     private

458.        pragma Import (C, FlagsTo API docTo spec, "ada_gparam_get_flags");

459.        pragma Import (C, Owner_TypeTo API docTo spec, "ada_gparam_get_owner_type");

460.        pragma Import (C, Value_TypeTo API docTo spec, "ada_gparam_get_value_type");

461.        pragma Import (C, Set_Value_TypeTo API docTo spec, "ada_gparam_set_value_type");

462.        pragma Import (C, Get_ValueTo API docTo spec, "g_enum_get_value");

463.        pragma Import (C, Flags_EnumerationTo API docTo spec, "ada_gparam_get_flags_flags");

464.        pragma Import (C, EnumerationTo API docTo spec, "ada_gparam_get_enum_class_enum");

465.        pragma Import (C, Install_PropertyTo API docTo spec, "g_object_class_install_property");

466.        pragma Import (C, UnrefTo API docTo spec, "g_param_spec_unref");

467.        pragma Import (C, Get_QdataTo API docTo spec, "g_param_spec_get_qdata");

468.        pragma Import (C, Set_QdataTo API docTo spec, "g_param_spec_set_qdata_full");

469.        pragma Import (C, Enum_Class_From_TypeTo API docTo spec, "g_type_class_ref");

470.        pragma Inline (DescriptionTo API docTo specTo body);

471.        pragma Inline (NameTo API docTo spec);

473.        pragma Inline (MinimumTo API docTo spec);

474.        pragma Inline (MaximumTo API docTo spec);

475.        pragma Inline (DefaultTo API docTo spec);

476.        pragma Inline (EpsilonTo API docTo specTo body);

477.        pragma Inline (SubstitutorTo API docTo specTo body);

478.        pragma Inline (Cset_NthTo API docTo specTo body);

479.        pragma Inline (Cset_FirstTo API docTo specTo body);

480.        pragma Inline (Ensure_Non_NullTo API docTo specTo body);

481.     end Glib.Properties.CreationTo API docTo specTo body;