1. ------------------------------------------------------------------------------ 
  2. --                                                                          -- 
  3. --      Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet       -- 
  4. --                     Copyright (C) 2000-2014, AdaCore                     -- 
  5. --                                                                          -- 
  6. -- This library is free software;  you can redistribute it and/or modify it -- 
  7. -- under terms of the  GNU General Public License  as published by the Free -- 
  8. -- Software  Foundation;  either version 3,  or (at your  option) any later -- 
  9. -- version. This library is distributed in the hope that it will be useful, -- 
  10. -- but WITHOUT ANY WARRANTY;  without even the implied warranty of MERCHAN- -- 
  11. -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            -- 
  12. --                                                                          -- 
  13. -- As a special exception under Section 7 of GPL version 3, you are granted -- 
  14. -- additional permissions described in the GCC Runtime Library Exception,   -- 
  15. -- version 3.1, as published by the Free Software Foundation.               -- 
  16. --                                                                          -- 
  17. -- You should have received a copy of the GNU General Public License and    -- 
  18. -- a copy of the GCC Runtime Library Exception along with this program;     -- 
  19. -- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    -- 
  20. -- <http://www.gnu.org/licenses/>.                                          -- 
  21. --                                                                          -- 
  22. ------------------------------------------------------------------------------ 
  23.  
  24. --  <description> 
  25. --  The Gtk.Label.Gtk_Label widget displays a small amount of text. As the 
  26. --  name implies, most labels are used to label another widget such as a 
  27. --  Gtk.Button.Gtk_Button, a Gtk.Menu_Item.Gtk_Menu_Item, or a 
  28. --  Gtk.Combo_Box.Gtk_Combo_Box. 
  29. -- 
  30. --  == GtkLabel as GtkBuildable == 
  31. -- 
  32. --  The GtkLabel implementation of the GtkBuildable interface supports a 
  33. --  custom <attributes> element, which supports any number of <attribute> 
  34. --  elements. the <attribute> element has attributes named name, value, start 
  35. --  and end and allows you to specify Pango.Attributes.Pango_Attribute values 
  36. --  for this label. 
  37. -- 
  38. --  == A UI definition fragment specifying Pango attributes == 
  39. -- 
  40. --    <object class="GtkLabel"> 
  41. --    <attributes> 
  42. --    <attribute name="weight" value="PANGO_WEIGHT_BOLD"/> 
  43. --    <attribute name="background" value="red" start="5" end="10"/>" 
  44. --    </attributes> 
  45. --    </object> 
  46. --  The start and end attributes specify the range of characters to which the 
  47. --  Pango attribute applies. If start and end are not specified, the attribute 
  48. --  is applied to the whole text. Note that specifying ranges does not make 
  49. --  much sense with translatable attributes. Use markup embedded in the 
  50. --  translatable content instead. 
  51. -- 
  52. --  == Mnemonics == 
  53. -- 
  54. --  Labels may contain 'mnemonics'. Mnemonics are underlined characters in the 
  55. --  label, used for keyboard navigation. Mnemonics are created by providing a 
  56. --  string with an underscore before the mnemonic character, such as '"_File"', 
  57. --  to the functions Gtk.Label.Gtk_New_With_Mnemonic or 
  58. --  Gtk.Label.Set_Text_With_Mnemonic. 
  59. -- 
  60. --  Mnemonics automatically activate any activatable widget the label is 
  61. --  inside, such as a Gtk.Button.Gtk_Button; if the label is not inside the 
  62. --  mnemonic's target widget, you have to tell the label about the target using 
  63. --  Gtk.Label.Set_Mnemonic_Widget. Here's a simple example where the label is 
  64. --  inside a button: 
  65. -- 
  66. --    // Pressing Alt+H will activate this button 
  67. --    button = gtk_button_new (<!-- -->); 
  68. --       label = gtk_label_new_with_mnemonic ("_Hello"); 
  69. --       gtk_container_add (GTK_CONTAINER (button), label); 
  70. -- 
  71. --  There's a convenience function to create buttons with a mnemonic label 
  72. --  already inside: 
  73. -- 
  74. --    // Pressing Alt+H will activate this button 
  75. --    button = gtk_button_new_with_mnemonic ("_Hello"); 
  76. -- 
  77. --  To create a mnemonic for a widget alongside the label, such as a 
  78. --  Gtk.GEntry.Gtk_Entry, you have to point the label at the entry with 
  79. --  Gtk.Label.Set_Mnemonic_Widget: 
  80. -- 
  81. --    // Pressing Alt+H will focus the entry 
  82. --    entry = gtk_entry_new (<!-- -->); 
  83. --       label = gtk_label_new_with_mnemonic ("_Hello"); 
  84. --       gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry); 
  85. -- 
  86. --  == Markup (styled text) == 
  87. -- 
  88. --  To make it easy to format text in a label (changing colors, fonts, etc.), 
  89. --  label text can be provided in a simple <link 
  90. --  linkend="PangoMarkupFormat">markup format</link>. Here's how to create a 
  91. --  label with a small font: 
  92. -- 
  93. --    label = gtk_label_new (NULL); 
  94. --    gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>"); 
  95. -- 
  96. --  (See <link linkend="PangoMarkupFormat">complete documentation</link> of 
  97. --  available tags in the Pango manual.) 
  98. -- 
  99. --  The markup passed to Gtk.Label.Set_Markup must be valid; for example, 
  100. --  literal <, > and &amp; characters must be escaped as \<, \gt;, and \&amp;. 
  101. --  If you pass text obtained from the user, file, or a network to 
  102. --  Gtk.Label.Set_Markup, you'll want to escape it with g_markup_escape_text or 
  103. --  g_markup_printf_escaped. 
  104. -- 
  105. --  Markup strings are just a convenient way to set the 
  106. --  Pango.Attributes.Pango_Attr_List on a label; Gtk.Label.Set_Attributes may 
  107. --  be a simpler way to set attributes in some cases. Be careful though; 
  108. --  Pango.Attributes.Pango_Attr_List tends to cause internationalization 
  109. --  problems, unless you're applying attributes to the entire string (i.e. 
  110. --  unless you set the range of each attribute to [0, G_MAXINT)). The reason is 
  111. --  that specifying the start_index and end_index for a 
  112. --  Pango.Attributes.Pango_Attribute requires knowledge of the exact string 
  113. --  being displayed, so translations will cause problems. 
  114. -- 
  115. --  == Selectable labels == 
  116. -- 
  117. --  Labels can be made selectable with Gtk.Label.Set_Selectable. Selectable 
  118. --  labels allow the user to copy the label contents to the clipboard. Only 
  119. --  labels that contain useful-to-copy information &mdash; such as error 
  120. --  messages &mdash; should be made selectable. 
  121. -- 
  122. --  == Text layout == 
  123. -- 
  124. --  A label can contain any number of paragraphs, but will have performance 
  125. --  problems if it contains more than a small number. Paragraphs are separated 
  126. --  by newlines or other paragraph separators understood by Pango. 
  127. -- 
  128. --  Labels can automatically wrap text if you call Gtk.Label.Set_Line_Wrap. 
  129. -- 
  130. --  Gtk.Label.Set_Justify sets how the lines in a label align with one 
  131. --  another. If you want to set how the label as a whole aligns in its 
  132. --  available space, see Gtk.Misc.Set_Alignment. 
  133. -- 
  134. --  The Gtk.Label.Gtk_Label:width-chars and 
  135. --  Gtk.Label.Gtk_Label:max-width-chars properties can be used to control the 
  136. --  size allocation of ellipsized or wrapped labels. For ellipsizing labels, if 
  137. --  either is specified (and less than the actual text size), it is used as the 
  138. --  minimum width, and the actual text size is used as the natural width of the 
  139. --  label. For wrapping labels, width-chars is used as the minimum width, if 
  140. --  specified, and max-width-chars is used as the natural width. Even if 
  141. --  max-width-chars specified, wrapping labels will be rewrapped to use all of 
  142. --  the available width. 
  143. -- 
  144. --  Note: 
  145. -- 
  146. --  Note that the interpretation of Gtk.Label.Gtk_Label:width-chars and 
  147. --  Gtk.Label.Gtk_Label:max-width-chars has changed a bit with the introduction 
  148. --  of <link linkend="geometry-management">width-for-height geometry 
  149. --  management.</link> 
  150. -- 
  151. --  == Links == 
  152. -- 
  153. --  Since 2.18, GTK+ supports markup for clickable hyperlinks in addition to 
  154. --  regular Pango markup. The markup for links is borrowed from HTML, using the 
  155. --  <tag>a</tag> with href and title attributes. GTK+ renders links similar to 
  156. --  the way they appear in web browsers, with colored, underlined text. The 
  157. --  title attribute is displayed as a tooltip on the link. An example looks 
  158. --  like this: 
  159. -- 
  160. --    gtk_label_set_markup (label, "Go to the <a href="http://www.gtk.org" title="<i>Our</i> website">GTK+ website</a> for more..."); 
  161. -- 
  162. --  It is possible to implement custom handling for links and their tooltips 
  163. --  with the Gtk.Label.Gtk_Label::activate-link signal and the 
  164. --  Gtk.Label.Get_Current_Uri function. 
  165. -- 
  166. -- 
  167. --  </description> 
  168. --  <screenshot>gtk-label</screenshot> 
  169. --  <group>Display widgets</group> 
  170. --  <testgtk>create_label.adb</testgtk> 
  171. pragma Ada_2005; 
  172.  
  173. pragma Warnings (Off, "*is already use-visible*"); 
  174. with Glib;             use Glib; 
  175. with Glib.Object;      use Glib.Object; 
  176. with Glib.Properties;  use Glib.Properties; 
  177. with Glib.Types;       use Glib.Types; 
  178. with Gtk.Buildable;    use Gtk.Buildable; 
  179. with Gtk.Enums;        use Gtk.Enums; 
  180. with Gtk.Menu;         use Gtk.Menu; 
  181. with Gtk.Misc;         use Gtk.Misc; 
  182. with Gtk.Widget;       use Gtk.Widget; 
  183. with Pango.Attributes; use Pango.Attributes; 
  184. with Pango.Enums;      use Pango.Enums; 
  185. with Pango.Layout;     use Pango.Layout; 
  186.  
  187. package Gtk.Label is 
  188.  
  189.    type Gtk_Label_Record is new Gtk_Misc_Record with null record; 
  190.    type Gtk_Label is access all Gtk_Label_Record'Class; 
  191.  
  192.    ------------------ 
  193.    -- Constructors -- 
  194.    ------------------ 
  195.  
  196.    procedure Gtk_New (Label : out Gtk_Label; Str : UTF8_String := ""); 
  197.    procedure Initialize 
  198.       (Label : not null access Gtk_Label_Record'Class; 
  199.        Str   : UTF8_String := ""); 
  200.    --  Creates a new label with the given text inside it. You can pass null to 
  201.    --  get an empty label widget. 
  202.    --  "str": The text of the label 
  203.  
  204.    function Gtk_Label_New (Str : UTF8_String := "") return Gtk_Label; 
  205.    --  Creates a new label with the given text inside it. You can pass null to 
  206.    --  get an empty label widget. 
  207.    --  "str": The text of the label 
  208.  
  209.    procedure Gtk_New_With_Mnemonic 
  210.       (Label : out Gtk_Label; 
  211.        Str   : UTF8_String); 
  212.    procedure Initialize_With_Mnemonic 
  213.       (Label : not null access Gtk_Label_Record'Class; 
  214.        Str   : UTF8_String); 
  215.    --  Creates a new Gtk.Label.Gtk_Label, containing the text in Str. 
  216.    --  If characters in Str are preceded by an underscore, they are 
  217.    --  underlined. If you need a literal underscore character in a label, use 
  218.    --  '__' (two underscores). The first underlined character represents a 
  219.    --  keyboard accelerator called a mnemonic. The mnemonic key can be used to 
  220.    --  activate another widget, chosen automatically, or explicitly using 
  221.    --  Gtk.Label.Set_Mnemonic_Widget. 
  222.    --  If Gtk.Label.Set_Mnemonic_Widget is not called, then the first 
  223.    --  activatable ancestor of the Gtk.Label.Gtk_Label will be chosen as the 
  224.    --  mnemonic widget. For instance, if the label is inside a button or menu 
  225.    --  item, the button or menu item will automatically become the mnemonic 
  226.    --  widget and be activated by the mnemonic. 
  227.    --  "str": The text of the label, with an underscore in front of the 
  228.    --  mnemonic character 
  229.  
  230.    function Gtk_Label_New_With_Mnemonic (Str : UTF8_String) return Gtk_Label; 
  231.    --  Creates a new Gtk.Label.Gtk_Label, containing the text in Str. 
  232.    --  If characters in Str are preceded by an underscore, they are 
  233.    --  underlined. If you need a literal underscore character in a label, use 
  234.    --  '__' (two underscores). The first underlined character represents a 
  235.    --  keyboard accelerator called a mnemonic. The mnemonic key can be used to 
  236.    --  activate another widget, chosen automatically, or explicitly using 
  237.    --  Gtk.Label.Set_Mnemonic_Widget. 
  238.    --  If Gtk.Label.Set_Mnemonic_Widget is not called, then the first 
  239.    --  activatable ancestor of the Gtk.Label.Gtk_Label will be chosen as the 
  240.    --  mnemonic widget. For instance, if the label is inside a button or menu 
  241.    --  item, the button or menu item will automatically become the mnemonic 
  242.    --  widget and be activated by the mnemonic. 
  243.    --  "str": The text of the label, with an underscore in front of the 
  244.    --  mnemonic character 
  245.  
  246.    function Get_Type return Glib.GType; 
  247.    pragma Import (C, Get_Type, "gtk_label_get_type"); 
  248.  
  249.    ------------- 
  250.    -- Methods -- 
  251.    ------------- 
  252.  
  253.    function Get_Angle 
  254.       (Label : not null access Gtk_Label_Record) return Gdouble; 
  255.    --  Gets the angle of rotation for the label. See Gtk.Label.Set_Angle. 
  256.    --  Since: gtk+ 2.6 
  257.  
  258.    procedure Set_Angle 
  259.       (Label : not null access Gtk_Label_Record; 
  260.        Angle : Gdouble); 
  261.    --  Sets the angle of rotation for the label. An angle of 90 reads from 
  262.    --  from bottom to top, an angle of 270, from top to bottom. The angle 
  263.    --  setting for the label is ignored if the label is selectable, wrapped, or 
  264.    --  ellipsized. 
  265.    --  Since: gtk+ 2.6 
  266.    --  "angle": the angle that the baseline of the label makes with the 
  267.    --  horizontal, in degrees, measured counterclockwise 
  268.  
  269.    function Get_Attributes 
  270.       (Label : not null access Gtk_Label_Record) 
  271.        return Pango.Attributes.Pango_Attr_List; 
  272.    --  Gets the attribute list that was set on the label using 
  273.    --  Gtk.Label.Set_Attributes, if any. This function does not reflect 
  274.    --  attributes that come from the labels markup (see Gtk.Label.Set_Markup). 
  275.    --  If you want to get the effective attributes for the label, use 
  276.    --  pango_layout_get_attribute (gtk_label_get_layout (label)). 
  277.  
  278.    procedure Set_Attributes 
  279.       (Label : not null access Gtk_Label_Record; 
  280.        Attrs : Pango.Attributes.Pango_Attr_List); 
  281.    --  Sets a Pango.Attributes.Pango_Attr_List; the attributes in the list are 
  282.    --  applied to the label text. 
  283.    --  Note: 
  284.    --  The attributes set with this function will be applied and merged with 
  285.    --  any other attributes previously effected by way of the 
  286.    --  Gtk.Label.Gtk_Label:use-underline or Gtk.Label.Gtk_Label:use-markup 
  287.    --  properties. While it is not recommended to mix markup strings with 
  288.    --  manually set attributes, if you must; know that the attributes will be 
  289.    --  applied to the label after the markup string is parsed. 
  290.    --  "attrs": a Pango.Attributes.Pango_Attr_List 
  291.  
  292.    function Get_Current_Uri 
  293.       (Label : not null access Gtk_Label_Record) return UTF8_String; 
  294.    --  Returns the URI for the currently active link in the label. The active 
  295.    --  link is the one under the mouse pointer or, in a selectable label, the 
  296.    --  link in which the text cursor is currently positioned. 
  297.    --  This function is intended for use in a 
  298.    --  Gtk.Label.Gtk_Label::activate-link handler or for use in a 
  299.    --  Gtk.Widget.Gtk_Widget::query-tooltip handler. 
  300.    --  Since: gtk+ 2.18 
  301.  
  302.    function Get_Ellipsize 
  303.       (Label : not null access Gtk_Label_Record) 
  304.        return Pango.Layout.Pango_Ellipsize_Mode; 
  305.    --  Returns the ellipsizing position of the label. See 
  306.    --  Gtk.Label.Set_Ellipsize. 
  307.    --  Since: gtk+ 2.6 
  308.  
  309.    procedure Set_Ellipsize 
  310.       (Label : not null access Gtk_Label_Record; 
  311.        Mode  : Pango.Layout.Pango_Ellipsize_Mode); 
  312.    --  Sets the mode used to ellipsize (add an ellipsis: "...") to the text if 
  313.    --  there is not enough space to render the entire string. 
  314.    --  Since: gtk+ 2.6 
  315.    --  "mode": a Pango.Layout.Pango_Ellipsize_Mode 
  316.  
  317.    function Get_Justify 
  318.       (Label : not null access Gtk_Label_Record) 
  319.        return Gtk.Enums.Gtk_Justification; 
  320.    --  Returns the justification of the label. See Gtk.Label.Set_Justify. 
  321.  
  322.    procedure Set_Justify 
  323.       (Label : not null access Gtk_Label_Record; 
  324.        Jtype : Gtk.Enums.Gtk_Justification); 
  325.    --  Sets the alignment of the lines in the text of the label relative to 
  326.    --  each other. Gtk.Enums.Justify_Left is the default value when the widget 
  327.    --  is first created with Gtk.Label.Gtk_New. If you instead want to set the 
  328.    --  alignment of the label as a whole, use Gtk.Misc.Set_Alignment instead. 
  329.    --  Gtk.Label.Set_Justify has no effect on labels containing only a single 
  330.    --  line. 
  331.    --  "jtype": a Gtk.Enums.Gtk_Justification 
  332.  
  333.    function Get_Label 
  334.       (Label : not null access Gtk_Label_Record) return UTF8_String; 
  335.    --  Fetches the text from a label widget including any embedded underlines 
  336.    --  indicating mnemonics and Pango markup. (See Gtk.Label.Get_Text). 
  337.  
  338.    procedure Set_Label 
  339.       (Label : not null access Gtk_Label_Record; 
  340.        Str   : UTF8_String); 
  341.    --  Sets the text of the label. The label is interpreted as including 
  342.    --  embedded underlines and/or Pango markup depending on the values of the 
  343.    --  Gtk.Label.Gtk_Label:use-underline" and Gtk.Label.Gtk_Label:use-markup 
  344.    --  properties. 
  345.    --  "str": the new text to set for the label 
  346.  
  347.    function Get_Layout 
  348.       (Label : not null access Gtk_Label_Record) 
  349.        return Pango.Layout.Pango_Layout; 
  350.    --  Gets the Pango.Layout.Pango_Layout used to display the label. The 
  351.    --  layout is useful to e.g. convert text positions to pixel positions, in 
  352.    --  combination with Gtk.Label.Get_Layout_Offsets. The returned layout is 
  353.    --  owned by the Label so need not be freed by the caller. The Label is free 
  354.    --  to recreate its layout at any time, so it should be considered 
  355.    --  read-only. 
  356.  
  357.    procedure Get_Layout_Offsets 
  358.       (Label : not null access Gtk_Label_Record; 
  359.        X     : out Gint; 
  360.        Y     : out Gint); 
  361.    --  Obtains the coordinates where the label will draw the 
  362.    --  Pango.Layout.Pango_Layout representing the text in the label; useful to 
  363.    --  convert mouse events into coordinates inside the 
  364.    --  Pango.Layout.Pango_Layout, e.g. to take some action if some part of the 
  365.    --  label is clicked. Of course you will need to create a 
  366.    --  Gtk.Event_Box.Gtk_Event_Box to receive the events, and pack the label 
  367.    --  inside it, since labels are a GTK_NO_WINDOW widget. Remember when using 
  368.    --  the Pango.Layout.Pango_Layout functions you need to convert to and from 
  369.    --  pixels using PANGO_PIXELS or PANGO_SCALE. 
  370.    --  "x": location to store X offset of layout, or null 
  371.    --  "y": location to store Y offset of layout, or null 
  372.  
  373.    function Get_Line_Wrap 
  374.       (Label : not null access Gtk_Label_Record) return Boolean; 
  375.    --  Returns whether lines in the label are automatically wrapped. See 
  376.    --  Gtk.Label.Set_Line_Wrap. 
  377.  
  378.    procedure Set_Line_Wrap 
  379.       (Label : not null access Gtk_Label_Record; 
  380.        Wrap  : Boolean); 
  381.    --  Toggles line wrapping within the Gtk.Label.Gtk_Label widget. True makes 
  382.    --  it break lines if text exceeds the widget's size. False lets the text 
  383.    --  get cut off by the edge of the widget if it exceeds the widget size. 
  384.    --  Note that setting line wrapping to True does not make the label wrap at 
  385.    --  its parent container's width, because GTK+ widgets conceptually can't 
  386.    --  make their requisition depend on the parent container's size. For a 
  387.    --  label that wraps at a specific position, set the label's width using 
  388.    --  Gtk.Widget.Set_Size_Request. 
  389.    --  "wrap": the setting 
  390.  
  391.    function Get_Line_Wrap_Mode 
  392.       (Label : not null access Gtk_Label_Record) 
  393.        return Pango.Enums.Wrap_Mode; 
  394.    --  Returns line wrap mode used by the label. See 
  395.    --  Gtk.Label.Set_Line_Wrap_Mode. 
  396.    --  Since: gtk+ 2.10 
  397.  
  398.    procedure Set_Line_Wrap_Mode 
  399.       (Label     : not null access Gtk_Label_Record; 
  400.        Wrap_Mode : Pango.Enums.Wrap_Mode); 
  401.    --  If line wrapping is on (see Gtk.Label.Set_Line_Wrap) this controls how 
  402.    --  the line wrapping is done. The default is Pango.Enums.Pango_Wrap_Word 
  403.    --  which means wrap on word boundaries. 
  404.    --  Since: gtk+ 2.10 
  405.    --  "wrap_mode": the line wrapping mode 
  406.  
  407.    function Get_Max_Width_Chars 
  408.       (Label : not null access Gtk_Label_Record) return Gint; 
  409.    --  Retrieves the desired maximum width of Label, in characters. See 
  410.    --  Gtk.Label.Set_Width_Chars. 
  411.    --  Since: gtk+ 2.6 
  412.  
  413.    procedure Set_Max_Width_Chars 
  414.       (Label   : not null access Gtk_Label_Record; 
  415.        N_Chars : Gint); 
  416.    --  Sets the desired maximum width in characters of Label to N_Chars. 
  417.    --  Since: gtk+ 2.6 
  418.    --  "n_chars": the new desired maximum width, in characters. 
  419.  
  420.    function Get_Mnemonic_Keyval 
  421.       (Label : not null access Gtk_Label_Record) return Guint; 
  422.    --  If the label has been set so that it has an mnemonic key this function 
  423.    --  returns the keyval used for the mnemonic accelerator. If there is no 
  424.    --  mnemonic set up it returns GDK_KEY_Void_Symbol. 
  425.  
  426.    function Get_Mnemonic_Widget 
  427.       (Label : not null access Gtk_Label_Record) 
  428.        return Gtk.Widget.Gtk_Widget; 
  429.    --  Retrieves the target of the mnemonic (keyboard shortcut) of this label. 
  430.    --  See Gtk.Label.Set_Mnemonic_Widget. 
  431.  
  432.    procedure Set_Mnemonic_Widget 
  433.       (Label  : not null access Gtk_Label_Record; 
  434.        Widget : access Gtk.Widget.Gtk_Widget_Record'Class); 
  435.    --  If the label has been set so that it has an mnemonic key (using i.e. 
  436.    --  Gtk.Label.Set_Markup_With_Mnemonic, Gtk.Label.Set_Text_With_Mnemonic, 
  437.    --  Gtk.Label.Gtk_New_With_Mnemonic or the "use_underline" property) the 
  438.    --  label can be associated with a widget that is the target of the 
  439.    --  mnemonic. When the label is inside a widget (like a 
  440.    --  Gtk.Button.Gtk_Button or a Gtk.Notebook.Gtk_Notebook tab) it is 
  441.    --  automatically associated with the correct widget, but sometimes (i.e. 
  442.    --  when the target is a Gtk.GEntry.Gtk_Entry next to the label) you need to 
  443.    --  set it explicitly using this function. 
  444.    --  The target widget will be accelerated by emitting the 
  445.    --  GtkWidget::mnemonic-activate signal on it. The default handler for this 
  446.    --  signal will activate the widget if there are no mnemonic collisions and 
  447.    --  toggle focus between the colliding widgets otherwise. 
  448.    --  "widget": the target Gtk.Widget.Gtk_Widget 
  449.  
  450.    function Get_Selectable 
  451.       (Label : not null access Gtk_Label_Record) return Boolean; 
  452.    --  Gets the value set by Gtk.Label.Set_Selectable. 
  453.  
  454.    procedure Set_Selectable 
  455.       (Label   : not null access Gtk_Label_Record; 
  456.        Setting : Boolean); 
  457.    --  Selectable labels allow the user to select text from the label, for 
  458.    --  copy-and-paste. 
  459.    --  "setting": True to allow selecting text in the label 
  460.  
  461.    procedure Get_Selection_Bounds 
  462.       (Label         : not null access Gtk_Label_Record; 
  463.        Start         : out Gint; 
  464.        The_End       : out Gint; 
  465.        Has_Selection : out Boolean); 
  466.    --  Gets the selected range of characters in the label, returning True if 
  467.    --  there's a selection. 
  468.    --  "start": return location for start of selection, as a character offset 
  469.    --  "end": return location for end of selection, as a character offset 
  470.  
  471.    function Get_Single_Line_Mode 
  472.       (Label : not null access Gtk_Label_Record) return Boolean; 
  473.    --  Returns whether the label is in single line mode. 
  474.    --  Since: gtk+ 2.6 
  475.  
  476.    procedure Set_Single_Line_Mode 
  477.       (Label            : not null access Gtk_Label_Record; 
  478.        Single_Line_Mode : Boolean); 
  479.    --  Sets whether the label is in single line mode. 
  480.    --  Since: gtk+ 2.6 
  481.    --  "single_line_mode": True if the label should be in single line mode 
  482.  
  483.    function Get_Text 
  484.       (Label : not null access Gtk_Label_Record) return UTF8_String; 
  485.    --  Fetches the text from a label widget, as displayed on the screen. This 
  486.    --  does not include any embedded underlines indicating mnemonics or Pango 
  487.    --  markup. (See Gtk.Label.Get_Label) 
  488.  
  489.    procedure Set_Text 
  490.       (Label : not null access Gtk_Label_Record; 
  491.        Str   : UTF8_String); 
  492.    --  Sets the text within the Gtk.Label.Gtk_Label widget. It overwrites any 
  493.    --  text that was there before. 
  494.    --  This will also clear any previously set mnemonic accelerators. 
  495.    --  "str": The text you want to set 
  496.  
  497.    function Get_Track_Visited_Links 
  498.       (Label : not null access Gtk_Label_Record) return Boolean; 
  499.    --  Returns whether the label is currently keeping track of clicked links. 
  500.    --  Since: gtk+ 2.18 
  501.  
  502.    procedure Set_Track_Visited_Links 
  503.       (Label       : not null access Gtk_Label_Record; 
  504.        Track_Links : Boolean); 
  505.    --  Sets whether the label should keep track of clicked links (and use a 
  506.    --  different color for them). 
  507.    --  Since: gtk+ 2.18 
  508.    --  "track_links": True to track visited links 
  509.  
  510.    function Get_Use_Markup 
  511.       (Label : not null access Gtk_Label_Record) return Boolean; 
  512.    --  Returns whether the label's text is interpreted as marked up with the 
  513.    --  <link linkend="PangoMarkupFormat">Pango text markup language</link>. See 
  514.    --  gtk_label_set_use_markup (). 
  515.  
  516.    procedure Set_Use_Markup 
  517.       (Label   : not null access Gtk_Label_Record; 
  518.        Setting : Boolean); 
  519.    --  Sets whether the text of the label contains markup in <link 
  520.    --  linkend="PangoMarkupFormat">Pango's text markup language</link>. See 
  521.    --  Gtk.Label.Set_Markup. 
  522.    --  "setting": True if the label's text should be parsed for markup. 
  523.  
  524.    function Get_Use_Underline 
  525.       (Label : not null access Gtk_Label_Record) return Boolean; 
  526.    --  Returns whether an embedded underline in the label indicates a 
  527.    --  mnemonic. See Gtk.Label.Set_Use_Underline. 
  528.  
  529.    procedure Set_Use_Underline 
  530.       (Label   : not null access Gtk_Label_Record; 
  531.        Setting : Boolean); 
  532.    --  If true, an underline in the text indicates the next character should 
  533.    --  be used for the mnemonic accelerator key. 
  534.    --  "setting": True if underlines in the text indicate mnemonics 
  535.  
  536.    function Get_Width_Chars 
  537.       (Label : not null access Gtk_Label_Record) return Gint; 
  538.    --  Retrieves the desired width of Label, in characters. See 
  539.    --  Gtk.Label.Set_Width_Chars. 
  540.    --  Since: gtk+ 2.6 
  541.  
  542.    procedure Set_Width_Chars 
  543.       (Label   : not null access Gtk_Label_Record; 
  544.        N_Chars : Gint); 
  545.    --  Sets the desired width in characters of Label to N_Chars. 
  546.    --  Since: gtk+ 2.6 
  547.    --  "n_chars": the new desired width, in characters. 
  548.  
  549.    procedure Select_Region 
  550.       (Label        : not null access Gtk_Label_Record; 
  551.        Start_Offset : Gint := -1; 
  552.        End_Offset   : Gint := -1); 
  553.    --  Selects a range of characters in the label, if the label is selectable. 
  554.    --  See Gtk.Label.Set_Selectable. If the label is not selectable, this 
  555.    --  function has no effect. If Start_Offset or End_Offset are -1, then the 
  556.    --  end of the label will be substituted. 
  557.    --  "start_offset": start offset (in characters not bytes) 
  558.    --  "end_offset": end offset (in characters not bytes) 
  559.  
  560.    procedure Set_Markup 
  561.       (Label : not null access Gtk_Label_Record; 
  562.        Str   : UTF8_String); 
  563.    --  Parses Str which is marked up with the <link 
  564.    --  linkend="PangoMarkupFormat">Pango text markup language</link>, setting 
  565.    --  the label's text and attribute list based on the parse results. If the 
  566.    --  Str is external data, you may need to escape it with 
  567.    --  g_markup_escape_text or g_markup_printf_escaped<!-- -->: |[ char 
  568.    --  *markup; 
  569.    --  markup = g_markup_printf_escaped ("<span style=\"italic\">%s</span>", 
  570.    --  str); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); 
  571.    --  ]| 
  572.    --  "str": a markup string (see <link linkend="PangoMarkupFormat">Pango 
  573.    --  markup format</link>) 
  574.  
  575.    procedure Set_Markup_With_Mnemonic 
  576.       (Label : not null access Gtk_Label_Record; 
  577.        Str   : UTF8_String); 
  578.    --  Parses Str which is marked up with the <link 
  579.    --  linkend="PangoMarkupFormat">Pango text markup language</link>, setting 
  580.    --  the label's text and attribute list based on the parse results. If 
  581.    --  characters in Str are preceded by an underscore, they are underlined 
  582.    --  indicating that they represent a keyboard accelerator called a mnemonic. 
  583.    --  The mnemonic key can be used to activate another widget, chosen 
  584.    --  automatically, or explicitly using Gtk.Label.Set_Mnemonic_Widget. 
  585.    --  "str": a markup string (see <link linkend="PangoMarkupFormat">Pango 
  586.    --  markup format</link>) 
  587.  
  588.    procedure Set_Pattern 
  589.       (Label   : not null access Gtk_Label_Record; 
  590.        Pattern : UTF8_String); 
  591.    --  Change the underlines pattern. 
  592.    --  Pattern is a simple string made of underscore and space characters, 
  593.    --  matching the ones in the string. GtkAda will underline every letter that 
  594.    --  matches an underscore. 
  595.    --  An empty string disables the underlines. 
  596.    --  example: If the text is FooBarBaz and the Pattern is "___ ___" then 
  597.    --  both "Foo" and "Baz" will be underlined, but not "Bar". 
  598.    --  "pattern": The pattern as described above. 
  599.  
  600.    procedure Set_Text_With_Mnemonic 
  601.       (Label : not null access Gtk_Label_Record; 
  602.        Str   : UTF8_String); 
  603.    --  Sets the label's text from the string Str. If characters in Str are 
  604.    --  preceded by an underscore, they are underlined indicating that they 
  605.    --  represent a keyboard accelerator called a mnemonic. The mnemonic key can 
  606.    --  be used to activate another widget, chosen automatically, or explicitly 
  607.    --  using Gtk.Label.Set_Mnemonic_Widget. 
  608.    --  "str": a string 
  609.  
  610.    ---------------- 
  611.    -- Properties -- 
  612.    ---------------- 
  613.    --  The following properties are defined for this widget. See 
  614.    --  Glib.Properties for more information on properties) 
  615.  
  616.    Angle_Property : constant Glib.Properties.Property_Double; 
  617.    --  Type: Gdouble 
  618.    --  The angle that the baseline of the label makes with the horizontal, in 
  619.    --  degrees, measured counterclockwise. An angle of 90 reads from from 
  620.    --  bottom to top, an angle of 270, from top to bottom. Ignored if the label 
  621.    --  is selectable, wrapped, or ellipsized. 
  622.  
  623.    Attributes_Property : constant Glib.Properties.Property_Object; 
  624.    --  Type: Pango.Attributes.Pango_Attr_List 
  625.  
  626.    Cursor_Position_Property : constant Glib.Properties.Property_Int; 
  627.  
  628.    Ellipsize_Property : constant Pango.Layout.Property_Pango_Ellipsize_Mode; 
  629.    --  Type: Pango.Layout.Pango_Ellipsize_Mode 
  630.    --  The preferred place to ellipsize the string, if the label does not have 
  631.    --  enough room to display the entire string, specified as a 
  632.    --  Pango.Layout.Pango_Ellipsize_Mode. 
  633.    -- 
  634.    --  Note that setting this property to a value other than 
  635.    --  Pango.Layout.Ellipsize_None has the side-effect that the label requests 
  636.    --  only enough space to display the ellipsis "...". In particular, this 
  637.    --  means that ellipsizing labels do not work well in notebook tabs, unless 
  638.    --  the tab's Gtk.Notebook.Gtk_Notebook:tab-expand property is set to True. 
  639.    --  Other ways to set a label's width are Gtk.Widget.Set_Size_Request and 
  640.    --  Gtk.Label.Set_Width_Chars. 
  641.  
  642.    Justify_Property : constant Gtk.Enums.Property_Gtk_Justification; 
  643.  
  644.    Label_Property : constant Glib.Properties.Property_String; 
  645.  
  646.    Max_Width_Chars_Property : constant Glib.Properties.Property_Int; 
  647.    --  The desired maximum width of the label, in characters. If this property 
  648.    --  is set to -1, the width will be calculated automatically. 
  649.    -- 
  650.    --  See the section on <link linkend="label-text-layout">text layout</link> 
  651.    --  for details of how Gtk.Label.Gtk_Label:width-chars and 
  652.    --  Gtk.Label.Gtk_Label:max-width-chars determine the width of ellipsized 
  653.    --  and wrapped labels. 
  654.  
  655.    Mnemonic_Keyval_Property : constant Glib.Properties.Property_Uint; 
  656.  
  657.    Mnemonic_Widget_Property : constant Glib.Properties.Property_Object; 
  658.    --  Type: Gtk.Widget.Gtk_Widget 
  659.  
  660.    Pattern_Property : constant Glib.Properties.Property_String; 
  661.    --  Flags: write 
  662.  
  663.    Selectable_Property : constant Glib.Properties.Property_Boolean; 
  664.  
  665.    Selection_Bound_Property : constant Glib.Properties.Property_Int; 
  666.  
  667.    Single_Line_Mode_Property : constant Glib.Properties.Property_Boolean; 
  668.    --  Whether the label is in single line mode. In single line mode, the 
  669.    --  height of the label does not depend on the actual text, it is always set 
  670.    --  to ascent + descent of the font. This can be an advantage in situations 
  671.    --  where resizing the label because of text changes would be distracting, 
  672.    --  e.g. in a statusbar. 
  673.  
  674.    Track_Visited_Links_Property : constant Glib.Properties.Property_Boolean; 
  675.    --  Set this property to True to make the label track which links have been 
  676.    --  clicked. It will then apply the ::visited-link-color color, instead of 
  677.    --  ::link-color. 
  678.  
  679.    Use_Markup_Property : constant Glib.Properties.Property_Boolean; 
  680.  
  681.    Use_Underline_Property : constant Glib.Properties.Property_Boolean; 
  682.  
  683.    Width_Chars_Property : constant Glib.Properties.Property_Int; 
  684.    --  The desired width of the label, in characters. If this property is set 
  685.    --  to -1, the width will be calculated automatically. 
  686.    -- 
  687.    --  See the section on <link linkend="label-text-layout">text layout</link> 
  688.    --  for details of how Gtk.Label.Gtk_Label:width-chars and 
  689.    --  Gtk.Label.Gtk_Label:max-width-chars determine the width of ellipsized 
  690.    --  and wrapped labels. 
  691.  
  692.    Wrap_Property : constant Glib.Properties.Property_Boolean; 
  693.  
  694.    Wrap_Mode_Property : constant Pango.Enums.Property_Wrap_Mode; 
  695.    --  Type: Pango.Enums.Wrap_Mode 
  696.    --  If line wrapping is on (see the Gtk.Label.Gtk_Label:wrap property) this 
  697.    --  controls how the line wrapping is done. The default is 
  698.    --  Pango.Enums.Pango_Wrap_Word, which means wrap on word boundaries. 
  699.  
  700.    ------------- 
  701.    -- Signals -- 
  702.    ------------- 
  703.  
  704.    type Cb_Gtk_Label_Void is not null access procedure (Self : access Gtk_Label_Record'Class); 
  705.  
  706.    type Cb_GObject_Void is not null access procedure 
  707.      (Self : access Glib.Object.GObject_Record'Class); 
  708.  
  709.    Signal_Activate_Current_Link : constant Glib.Signal_Name := "activate-current-link"; 
  710.    procedure On_Activate_Current_Link 
  711.       (Self  : not null access Gtk_Label_Record; 
  712.        Call  : Cb_Gtk_Label_Void; 
  713.        After : Boolean := False); 
  714.    procedure On_Activate_Current_Link 
  715.       (Self  : not null access Gtk_Label_Record; 
  716.        Call  : Cb_GObject_Void; 
  717.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  718.        After : Boolean := False); 
  719.    --  A <link linkend="keybinding-signals">keybinding signal</link> which 
  720.    --  gets emitted when the user activates a link in the label. 
  721.    -- 
  722.    --  Applications may also emit the signal with g_signal_emit_by_name if 
  723.    --  they need to control activation of URIs programmatically. 
  724.    -- 
  725.    --  The default bindings for this signal are all forms of the Enter key. 
  726.  
  727.    type Cb_Gtk_Label_UTF8_String_Boolean is not null access function 
  728.      (Self : access Gtk_Label_Record'Class; 
  729.       URI  : UTF8_String) return Boolean; 
  730.  
  731.    type Cb_GObject_UTF8_String_Boolean is not null access function 
  732.      (Self : access Glib.Object.GObject_Record'Class; 
  733.       URI  : UTF8_String) return Boolean; 
  734.  
  735.    Signal_Activate_Link : constant Glib.Signal_Name := "activate-link"; 
  736.    procedure On_Activate_Link 
  737.       (Self  : not null access Gtk_Label_Record; 
  738.        Call  : Cb_Gtk_Label_UTF8_String_Boolean; 
  739.        After : Boolean := False); 
  740.    procedure On_Activate_Link 
  741.       (Self  : not null access Gtk_Label_Record; 
  742.        Call  : Cb_GObject_UTF8_String_Boolean; 
  743.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  744.        After : Boolean := False); 
  745.    --  The signal which gets emitted to activate a URI. Applications may 
  746.    --  connect to it to override the default behaviour, which is to call 
  747.    --  gtk_show_uri(). 
  748.    --  
  749.    --  Callback parameters: 
  750.    --    --  "uri": the URI that is activated 
  751.    --    --  Returns True if the link has been activated 
  752.  
  753.    Signal_Copy_Clipboard : constant Glib.Signal_Name := "copy-clipboard"; 
  754.    procedure On_Copy_Clipboard 
  755.       (Self  : not null access Gtk_Label_Record; 
  756.        Call  : Cb_Gtk_Label_Void; 
  757.        After : Boolean := False); 
  758.    procedure On_Copy_Clipboard 
  759.       (Self  : not null access Gtk_Label_Record; 
  760.        Call  : Cb_GObject_Void; 
  761.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  762.        After : Boolean := False); 
  763.    --  The ::copy-clipboard signal is a <link 
  764.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  765.    --  to copy the selection to the clipboard. 
  766.    -- 
  767.    --  The default binding for this signal is Ctrl-c. 
  768.  
  769.    type Cb_Gtk_Label_Gtk_Movement_Step_Gint_Boolean_Void is not null access procedure 
  770.      (Self             : access Gtk_Label_Record'Class; 
  771.       Step             : Gtk.Enums.Gtk_Movement_Step; 
  772.       Count            : Gint; 
  773.       Extend_Selection : Boolean); 
  774.  
  775.    type Cb_GObject_Gtk_Movement_Step_Gint_Boolean_Void is not null access procedure 
  776.      (Self             : access Glib.Object.GObject_Record'Class; 
  777.       Step             : Gtk.Enums.Gtk_Movement_Step; 
  778.       Count            : Gint; 
  779.       Extend_Selection : Boolean); 
  780.  
  781.    Signal_Move_Cursor : constant Glib.Signal_Name := "move-cursor"; 
  782.    procedure On_Move_Cursor 
  783.       (Self  : not null access Gtk_Label_Record; 
  784.        Call  : Cb_Gtk_Label_Gtk_Movement_Step_Gint_Boolean_Void; 
  785.        After : Boolean := False); 
  786.    procedure On_Move_Cursor 
  787.       (Self  : not null access Gtk_Label_Record; 
  788.        Call  : Cb_GObject_Gtk_Movement_Step_Gint_Boolean_Void; 
  789.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  790.        After : Boolean := False); 
  791.    --  The ::move-cursor signal is a <link 
  792.    --  linkend="keybinding-signals">keybinding signal</link> which gets emitted 
  793.    --  when the user initiates a cursor movement. If the cursor is not visible 
  794.    --  in Entry, this signal causes the viewport to be moved instead. 
  795.    -- 
  796.    --  Applications should not connect to it, but may emit it with 
  797.    --  g_signal_emit_by_name if they need to control the cursor 
  798.    --  programmatically. 
  799.    -- 
  800.    --  The default bindings for this signal come in two variants, the variant 
  801.    --  with the Shift modifier extends the selection, the variant without the 
  802.    --  Shift modifer does not. There are too many key combinations to list them 
  803.    --  all here. 
  804.    -- 
  805.    --     * Arrow keys move by individual characters/lines 
  806.    -- 
  807.    --     * Ctrl-arrow key combinations move by words/paragraphs 
  808.    -- 
  809.    --     * Home/End keys move to the ends of the buffer 
  810.    --  
  811.    --  Callback parameters: 
  812.    --    --  "step": the granularity of the move, as a Gtk.Enums.Gtk_Movement_Step 
  813.    --    --  "count": the number of Step units to move 
  814.    --    --  "extend_selection": True if the move should extend the selection 
  815.  
  816.    type Cb_Gtk_Label_Gtk_Menu_Void is not null access procedure 
  817.      (Self : access Gtk_Label_Record'Class; 
  818.       Menu : not null access Gtk.Menu.Gtk_Menu_Record'Class); 
  819.  
  820.    type Cb_GObject_Gtk_Menu_Void is not null access procedure 
  821.      (Self : access Glib.Object.GObject_Record'Class; 
  822.       Menu : not null access Gtk.Menu.Gtk_Menu_Record'Class); 
  823.  
  824.    Signal_Populate_Popup : constant Glib.Signal_Name := "populate-popup"; 
  825.    procedure On_Populate_Popup 
  826.       (Self  : not null access Gtk_Label_Record; 
  827.        Call  : Cb_Gtk_Label_Gtk_Menu_Void; 
  828.        After : Boolean := False); 
  829.    procedure On_Populate_Popup 
  830.       (Self  : not null access Gtk_Label_Record; 
  831.        Call  : Cb_GObject_Gtk_Menu_Void; 
  832.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  833.        After : Boolean := False); 
  834.    --  The ::populate-popup signal gets emitted before showing the context 
  835.    --  menu of the label. Note that only selectable labels have context menus. 
  836.    -- 
  837.    --  If you need to add items to the context menu, connect to this signal 
  838.    --  and append your menuitems to the Menu. 
  839.  
  840.    ---------------- 
  841.    -- Interfaces -- 
  842.    ---------------- 
  843.    --  This class implements several interfaces. See Glib.Types 
  844.    -- 
  845.    --  - "Buildable" 
  846.  
  847.    package Implements_Gtk_Buildable is new Glib.Types.Implements 
  848.      (Gtk.Buildable.Gtk_Buildable, Gtk_Label_Record, Gtk_Label); 
  849.    function "+" 
  850.      (Widget : access Gtk_Label_Record'Class) 
  851.    return Gtk.Buildable.Gtk_Buildable 
  852.    renames Implements_Gtk_Buildable.To_Interface; 
  853.    function "-" 
  854.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  855.    return Gtk_Label 
  856.    renames Implements_Gtk_Buildable.To_Object; 
  857.  
  858. private 
  859.    Wrap_Mode_Property : constant Pango.Enums.Property_Wrap_Mode := 
  860.      Pango.Enums.Build ("wrap-mode"); 
  861.    Wrap_Property : constant Glib.Properties.Property_Boolean := 
  862.      Glib.Properties.Build ("wrap"); 
  863.    Width_Chars_Property : constant Glib.Properties.Property_Int := 
  864.      Glib.Properties.Build ("width-chars"); 
  865.    Use_Underline_Property : constant Glib.Properties.Property_Boolean := 
  866.      Glib.Properties.Build ("use-underline"); 
  867.    Use_Markup_Property : constant Glib.Properties.Property_Boolean := 
  868.      Glib.Properties.Build ("use-markup"); 
  869.    Track_Visited_Links_Property : constant Glib.Properties.Property_Boolean := 
  870.      Glib.Properties.Build ("track-visited-links"); 
  871.    Single_Line_Mode_Property : constant Glib.Properties.Property_Boolean := 
  872.      Glib.Properties.Build ("single-line-mode"); 
  873.    Selection_Bound_Property : constant Glib.Properties.Property_Int := 
  874.      Glib.Properties.Build ("selection-bound"); 
  875.    Selectable_Property : constant Glib.Properties.Property_Boolean := 
  876.      Glib.Properties.Build ("selectable"); 
  877.    Pattern_Property : constant Glib.Properties.Property_String := 
  878.      Glib.Properties.Build ("pattern"); 
  879.    Mnemonic_Widget_Property : constant Glib.Properties.Property_Object := 
  880.      Glib.Properties.Build ("mnemonic-widget"); 
  881.    Mnemonic_Keyval_Property : constant Glib.Properties.Property_Uint := 
  882.      Glib.Properties.Build ("mnemonic-keyval"); 
  883.    Max_Width_Chars_Property : constant Glib.Properties.Property_Int := 
  884.      Glib.Properties.Build ("max-width-chars"); 
  885.    Label_Property : constant Glib.Properties.Property_String := 
  886.      Glib.Properties.Build ("label"); 
  887.    Justify_Property : constant Gtk.Enums.Property_Gtk_Justification := 
  888.      Gtk.Enums.Build ("justify"); 
  889.    Ellipsize_Property : constant Pango.Layout.Property_Pango_Ellipsize_Mode := 
  890.      Pango.Layout.Build ("ellipsize"); 
  891.    Cursor_Position_Property : constant Glib.Properties.Property_Int := 
  892.      Glib.Properties.Build ("cursor-position"); 
  893.    Attributes_Property : constant Glib.Properties.Property_Object := 
  894.      Glib.Properties.Build ("attributes"); 
  895.    Angle_Property : constant Glib.Properties.Property_Double := 
  896.      Glib.Properties.Build ("angle"); 
  897. end Gtk.Label;