1. ----------------------------------------------------------------------- 
  2. --               GtkAda - Ada95 binding for Gtk+/Gnome               -- 
  3. --                                                                   -- 
  4. --   Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet   -- 
  5. --                Copyright (C) 2000-2013, AdaCore                   -- 
  6. --                                                                   -- 
  7. -- This library is free software; you can redistribute it and/or     -- 
  8. -- modify it under the terms of the GNU General Public               -- 
  9. -- License as published by the Free Software Foundation; either      -- 
  10. -- version 2 of the License, or (at your option) any later version.  -- 
  11. --                                                                   -- 
  12. -- This library is distributed in the hope that it will be useful,   -- 
  13. -- but WITHOUT ANY WARRANTY; without even the implied warranty of    -- 
  14. -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU -- 
  15. -- General Public License for more details.                          -- 
  16. --                                                                   -- 
  17. -- You should have received a copy of the GNU General Public         -- 
  18. -- License along with this library; if not, write to the             -- 
  19. -- Free Software Foundation, Inc., 59 Temple Place - Suite 330,      -- 
  20. -- Boston, MA 02111-1307, USA.                                       -- 
  21. --                                                                   -- 
  22. -- As a special exception, if other files instantiate generics from  -- 
  23. -- this unit, or you link this unit with other files to produce an   -- 
  24. -- executable, this  unit  does not  by itself cause  the resulting  -- 
  25. -- executable to be covered by the GNU General Public License. This  -- 
  26. -- exception does not however invalidate any other reasons why the   -- 
  27. -- executable file  might be covered by the  GNU Public License.     -- 
  28. ----------------------------------------------------------------------- 
  29.  
  30. --  <description> 
  31. --  The Gtk_Image widget displays a graphical image. The image is typically 
  32. --  created using Gdk.Image.Gdk_New. 
  33. -- 
  34. --  The pixels in a Gtk_Image may be manipulated by the application after 
  35. --  creation, as Gtk_Image store the pixel data on the client side. If you wish 
  36. --  to store the pixel data on the server side (thus not allowing manipulation 
  37. --  of the data after creation) you should use Gtk_Pixmap. 
  38. -- 
  39. --  </description> 
  40. --  <screenshot>gtk-image</screenshot> 
  41. --  <group>Display widgets</group> 
  42.  
  43. pragma Warnings (Off, "*is already use-visible*"); 
  44. with GNAT.Strings;     use GNAT.Strings; 
  45. with Gdk.Bitmap;       use Gdk.Bitmap; 
  46. with Gdk.Image;        use Gdk.Image; 
  47. with Gdk.Pixbuf;       use Gdk.Pixbuf; 
  48. with Gdk.Pixmap;       use Gdk.Pixmap; 
  49. with Glib;             use Glib; 
  50. with Glib.G_Icon;      use Glib.G_Icon; 
  51. with Glib.Properties;  use Glib.Properties; 
  52. with Glib.Types;       use Glib.Types; 
  53. with Gtk.Buildable;    use Gtk.Buildable; 
  54. with Gtk.Enums;        use Gtk.Enums; 
  55. with Gtk.Icon_Factory; use Gtk.Icon_Factory; 
  56. with Gtk.Misc;         use Gtk.Misc; 
  57. with Gtk.Widget;       use Gtk.Widget; 
  58.  
  59. package Gtk.Image is 
  60.  
  61.    type Gtk_Image_Record is new Gtk_Misc_Record with null record; 
  62.    type Gtk_Image is access all Gtk_Image_Record'Class; 
  63.  
  64.    type Gtk_Image_Type is 
  65.         (Image_Empty, 
  66.          Image_Pixmap, 
  67.          Image_Image, 
  68.          Image_Pixbuf, 
  69.          Image_Stock, 
  70.          Image_Icon_Set, 
  71.          Image_Animation, 
  72.          Image_Icon_Name, 
  73.          Image_Gicon); 
  74.       pragma Convention (C, Gtk_Image_Type); 
  75.  
  76.    ------------------ 
  77.    -- Constructors -- 
  78.    ------------------ 
  79.  
  80.    procedure Gtk_New (Image : out Gtk_Image); 
  81.    procedure Initialize (Image : access Gtk_Image_Record'Class); 
  82.    --  Creates a new empty Gtk.Image.Gtk_Image widget. 
  83.  
  84.    procedure Gtk_New 
  85.       (Image     : out Gtk_Image; 
  86.        Animation : Gdk.Pixbuf.Gdk_Pixbuf_Animation); 
  87.    procedure Initialize 
  88.       (Image     : access Gtk_Image_Record'Class; 
  89.        Animation : Gdk.Pixbuf.Gdk_Pixbuf_Animation); 
  90.    --  Creates a Gtk.Image.Gtk_Image displaying the given animation. The 
  91.    --  Gtk.Image.Gtk_Image does not assume a reference to the animation; you 
  92.    --  still need to unref it if you own references. Gtk.Image.Gtk_Image will 
  93.    --  add its own reference rather than adopting yours. Note that the 
  94.    --  animation frames are shown using a timeout with G_PRIORITY_DEFAULT. When 
  95.    --  using animations to indicate busyness, keep in mind that the animation 
  96.    --  will only be shown if the main loop is not busy with something that has 
  97.    --  a higher priority. 
  98.    --  "animation": an animation 
  99.  
  100.    procedure Gtk_New (Image : out Gtk_Image; Filename : UTF8_String); 
  101.    procedure Initialize 
  102.       (Image    : access Gtk_Image_Record'Class; 
  103.        Filename : UTF8_String); 
  104.    --  Creates a new Gtk.Image.Gtk_Image displaying the file Filename. If the 
  105.    --  file isn't found or can't be loaded, the resulting Gtk.Image.Gtk_Image 
  106.    --  will display a "broken image" icon. This function never returns null, it 
  107.    --  always returns a valid Gtk.Image.Gtk_Image widget. If the file contains 
  108.    --  an animation, the image will contain an animation. If you need to detect 
  109.    --  failures to load the file, use Gdk.Pixbuf.Gdk_New_From_File to load the 
  110.    --  file yourself, then create the Gtk.Image.Gtk_Image from the pixbuf. (Or 
  111.    --  for animations, use Gdk.Pixbuf.Gdk_New_From_File). The storage type 
  112.    --  (gtk_image_get_storage_type) of the returned image is not defined, it 
  113.    --  will be whatever is appropriate for displaying the file. 
  114.    --  "filename": a filename 
  115.  
  116.    procedure Gtk_New_From_Gicon 
  117.       (Image : out Gtk_Image; 
  118.        Icon  : Glib.G_Icon.G_Icon; 
  119.        Size  : Gtk.Enums.Gtk_Icon_Size); 
  120.    procedure Initialize_From_Gicon 
  121.       (Image : access Gtk_Image_Record'Class; 
  122.        Icon  : Glib.G_Icon.G_Icon; 
  123.        Size  : Gtk.Enums.Gtk_Icon_Size); 
  124.    --  Creates a Gtk.Image.Gtk_Image displaying an icon from the current icon 
  125.    --  theme. If the icon name isn't known, a "broken image" icon will be 
  126.    --  displayed instead. If the current icon theme is changed, the icon will 
  127.    --  be updated appropriately. 
  128.    --  Since: gtk+ 2.14 
  129.    --  "icon": an icon 
  130.    --  "size": a stock icon size 
  131.  
  132.    procedure Gtk_New_From_Icon_Name 
  133.       (Image     : out Gtk_Image; 
  134.        Icon_Name : UTF8_String; 
  135.        Size      : Gtk.Enums.Gtk_Icon_Size); 
  136.    procedure Initialize_From_Icon_Name 
  137.       (Image     : access Gtk_Image_Record'Class; 
  138.        Icon_Name : UTF8_String; 
  139.        Size      : Gtk.Enums.Gtk_Icon_Size); 
  140.    --  Creates a Gtk.Image.Gtk_Image displaying an icon from the current icon 
  141.    --  theme. If the icon name isn't known, a "broken image" icon will be 
  142.    --  displayed instead. If the current icon theme is changed, the icon will 
  143.    --  be updated appropriately. 
  144.    --  Since: gtk+ 2.6 
  145.    --  "icon_name": an icon name 
  146.    --  "size": a stock icon size 
  147.  
  148.    procedure Gtk_New 
  149.       (Image    : out Gtk_Image; 
  150.        Icon_Set : Gtk.Icon_Factory.Gtk_Icon_Set; 
  151.        Size     : Gtk.Enums.Gtk_Icon_Size); 
  152.    procedure Initialize 
  153.       (Image    : access Gtk_Image_Record'Class; 
  154.        Icon_Set : Gtk.Icon_Factory.Gtk_Icon_Set; 
  155.        Size     : Gtk.Enums.Gtk_Icon_Size); 
  156.    --  Creates a Gtk.Image.Gtk_Image displaying an icon set. Sample stock 
  157.    --  sizes are GTK_ICON_SIZE_MENU, GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of 
  158.    --  using this function, usually it's better to create a 
  159.    --  Gtk.Iconfactory.Gtk_Iconfactory, put your icon sets in the icon factory, 
  160.    --  add the icon factory to the list of default factories with 
  161.    --  Gtk.Icon_Factory.Add_Default, and then use Gtk.Image.Gtk_New. This will 
  162.    --  allow themes to override the icon you ship with your application. The 
  163.    --  Gtk.Image.Gtk_Image does not assume a reference to the icon set; you 
  164.    --  still need to unref it if you own references. Gtk.Image.Gtk_Image will 
  165.    --  add its own reference rather than adopting yours. 
  166.    --  "icon_set": a GtkIconSet 
  167.    --  "size": a stock icon size 
  168.  
  169.    procedure Gtk_New 
  170.       (Image : out Gtk_Image; 
  171.        Val   : Gdk.Image.Gdk_Image; 
  172.        Mask  : Gdk.Bitmap.Gdk_Bitmap); 
  173.    procedure Initialize 
  174.       (Image : access Gtk_Image_Record'Class; 
  175.        Val   : Gdk.Image.Gdk_Image; 
  176.        Mask  : Gdk.Bitmap.Gdk_Bitmap); 
  177.    --  Creates a Gtk.Image.Gtk_Image widget displaying a Image with a Mask. A 
  178.    --  GdkImage is a client-side image buffer in the pixel format of the 
  179.    --  current display. The Gtk.Image.Gtk_Image does not assume a reference to 
  180.    --  the image or mask; you still need to unref them if you own references. 
  181.    --  Gtk.Image.Gtk_Image will add its own reference rather than adopting 
  182.    --  yours. 
  183.    --  "Val": a GdkImage, or null 
  184.    --  "mask": a GdkBitmap, or null 
  185.  
  186.    procedure Gtk_New 
  187.       (Image  : out Gtk_Image; 
  188.        Pixbuf : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); 
  189.    procedure Initialize 
  190.       (Image  : access Gtk_Image_Record'Class; 
  191.        Pixbuf : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); 
  192.    --  Creates a new Gtk.Image.Gtk_Image displaying Pixbuf. The 
  193.    --  Gtk.Image.Gtk_Image does not assume a reference to the pixbuf; you still 
  194.    --  need to unref it if you own references. Gtk.Image.Gtk_Image will add its 
  195.    --  own reference rather than adopting yours. Note that this function just 
  196.    --  creates an Gtk.Image.Gtk_Image from the pixbuf. The Gtk.Image.Gtk_Image 
  197.    --  created will not react to state changes. Should you want that, you 
  198.    --  should use Gtk.Image.Gtk_New. 
  199.    --  "pixbuf": a Gdk.Pixbuf.Gdk_Pixbuf, or null 
  200.  
  201.    procedure Gtk_New 
  202.       (Image  : out Gtk_Image; 
  203.        Pixmap : Gdk.Pixmap.Gdk_Pixmap; 
  204.        Mask   : Gdk.Bitmap.Gdk_Bitmap); 
  205.    procedure Initialize 
  206.       (Image  : access Gtk_Image_Record'Class; 
  207.        Pixmap : Gdk.Pixmap.Gdk_Pixmap; 
  208.        Mask   : Gdk.Bitmap.Gdk_Bitmap); 
  209.    --  Creates a Gtk.Image.Gtk_Image widget displaying Pixmap with a Mask. A 
  210.    --  GdkPixmap is a server-side image buffer in the pixel format of the 
  211.    --  current display. The Gtk.Image.Gtk_Image does not assume a reference to 
  212.    --  the pixmap or mask; you still need to unref them if you own references. 
  213.    --  Gtk.Image.Gtk_Image will add its own reference rather than adopting 
  214.    --  yours. 
  215.    --  "pixmap": a GdkPixmap, or null 
  216.    --  "mask": a GdkBitmap, or null 
  217.  
  218.    procedure Gtk_New 
  219.       (Image    : out Gtk_Image; 
  220.        Stock_Id : UTF8_String; 
  221.        Size     : Gtk.Enums.Gtk_Icon_Size); 
  222.    procedure Initialize 
  223.       (Image    : access Gtk_Image_Record'Class; 
  224.        Stock_Id : UTF8_String; 
  225.        Size     : Gtk.Enums.Gtk_Icon_Size); 
  226.    --  Creates a Gtk.Image.Gtk_Image displaying a stock icon. Sample stock 
  227.    --  icon names are GTK_STOCK_OPEN, GTK_STOCK_QUIT. Sample stock sizes are 
  228.    --  GTK_ICON_SIZE_MENU, GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock icon name 
  229.    --  isn't known, the image will be empty. You can register your own stock 
  230.    --  icon names, see Gtk.Icon_Factory.Add_Default and Gtk.Icon_Factory.Add. 
  231.    --  "stock_id": a stock icon name 
  232.    --  "size": a stock icon size 
  233.  
  234.    function Get_Type return Glib.GType; 
  235.    pragma Import (C, Get_Type, "gtk_image_get_type"); 
  236.  
  237.    ------------- 
  238.    -- Methods -- 
  239.    ------------- 
  240.  
  241.    procedure Clear (Image : access Gtk_Image_Record); 
  242.    --  Resets the image to be empty. 
  243.    --  Since: gtk+ 2.8 
  244.  
  245.    function Get 
  246.       (Image : access Gtk_Image_Record) 
  247.        return Gdk.Pixbuf.Gdk_Pixbuf_Animation; 
  248.    procedure Get 
  249.       (Image : access Gtk_Image_Record; 
  250.        Gicon : out Glib.G_Icon.G_Icon; 
  251.        Size  : out Gtk.Enums.Gtk_Icon_Size); 
  252.    procedure Get 
  253.       (Image    : access Gtk_Image_Record; 
  254.        Icon_Set : out Gtk.Icon_Factory.Gtk_Icon_Set; 
  255.        Size     : out Gtk.Enums.Gtk_Icon_Size); 
  256.    procedure Get 
  257.       (Image     : access Gtk_Image_Record; 
  258.        Gdk_Image : out Gdk.Image.Gdk_Image; 
  259.        Mask      : out Gdk.Bitmap.Gdk_Bitmap); 
  260.    function Get 
  261.       (Image : access Gtk_Image_Record) return Gdk.Pixbuf.Gdk_Pixbuf; 
  262.    procedure Get 
  263.       (Image  : access Gtk_Image_Record; 
  264.        Pixmap : out Gdk.Pixmap.Gdk_Pixmap; 
  265.        Mask   : out Gdk.Bitmap.Gdk_Bitmap); 
  266.    --  Gets the pixmap and mask being displayed by the Gtk.Image.Gtk_Image. 
  267.    --  The storage type of the image must be %GTK_IMAGE_EMPTY or 
  268.    --  %GTK_IMAGE_PIXMAP (see Gtk.Image.Get_Storage_Type). The caller of this 
  269.    --  function does not own a reference to the returned pixmap and mask. 
  270.    --  "pixmap": location to store the pixmap, or null 
  271.    --  "mask": location to store the mask, or null 
  272.  
  273.    function Get_Pixel_Size (Image : access Gtk_Image_Record) return Gint; 
  274.    procedure Set_Pixel_Size 
  275.       (Image      : access Gtk_Image_Record; 
  276.        Pixel_Size : Gint); 
  277.    --  Sets the pixel size to use for named icons. If the pixel size is set to 
  278.    --  a value != -1, it is used instead of the icon size set by 
  279.    --  Gtk.Image.Set_From_Icon_Name. 
  280.    --  Since: gtk+ 2.6 
  281.    --  "pixel_size": the new pixel size 
  282.  
  283.    function Get_Storage_Type 
  284.       (Image : access Gtk_Image_Record) return Gtk_Image_Type; 
  285.    --  Gets the type of representation being used by the Gtk.Image.Gtk_Image 
  286.    --  to store image data. If the Gtk.Image.Gtk_Image has no image data, the 
  287.    --  return value will be %GTK_IMAGE_EMPTY. 
  288.  
  289.    procedure Set 
  290.       (Image     : access Gtk_Image_Record; 
  291.        Animation : Gdk.Pixbuf.Gdk_Pixbuf_Animation); 
  292.    procedure Set (Image : access Gtk_Image_Record; Filename : UTF8_String); 
  293.    procedure Set 
  294.       (Image : access Gtk_Image_Record; 
  295.        Icon  : Glib.G_Icon.G_Icon; 
  296.        Size  : Gtk.Enums.Gtk_Icon_Size); 
  297.    procedure Set 
  298.       (Image    : access Gtk_Image_Record; 
  299.        Icon_Set : Gtk.Icon_Factory.Gtk_Icon_Set; 
  300.        Size     : Gtk.Enums.Gtk_Icon_Size); 
  301.    procedure Set 
  302.       (Image     : access Gtk_Image_Record; 
  303.        Gdk_Image : Gdk.Image.Gdk_Image; 
  304.        Mask      : Gdk.Bitmap.Gdk_Bitmap); 
  305.    procedure Set 
  306.       (Image  : access Gtk_Image_Record; 
  307.        Pixbuf : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); 
  308.    procedure Set 
  309.       (Image  : access Gtk_Image_Record; 
  310.        Pixmap : Gdk.Pixmap.Gdk_Pixmap; 
  311.        Mask   : Gdk.Bitmap.Gdk_Bitmap); 
  312.    procedure Set 
  313.       (Image    : access Gtk_Image_Record; 
  314.        Stock_Id : UTF8_String; 
  315.        Size     : Gtk.Enums.Gtk_Icon_Size); 
  316.    --  See Gtk.Image.Gtk_New for details. 
  317.    --  "stock_id": a stock icon name 
  318.    --  "size": a stock icon size 
  319.  
  320.    procedure Set_From_Icon_Name 
  321.       (Image     : access Gtk_Image_Record; 
  322.        Icon_Name : UTF8_String; 
  323.        Size      : Gtk.Enums.Gtk_Icon_Size); 
  324.    --  See Gtk.Image.Gtk_New_From_Icon_Name for details. 
  325.    --  Since: gtk+ 2.6 
  326.    --  "icon_name": an icon name 
  327.    --  "size": an icon size 
  328.  
  329.    ---------------------- 
  330.    -- GtkAda additions -- 
  331.    ---------------------- 
  332.  
  333.    function Get 
  334.      (Image : access Gtk_Image_Record; 
  335.       Size  : access Gtk.Enums.Gtk_Icon_Size) return String; 
  336.    --  Get the stock_id for the image displayed 
  337.  
  338.    procedure Get_Icon_Name 
  339.      (Image : access Gtk_Image_Record; 
  340.       Name  : out GNAT.Strings.String_Access; 
  341.       Size  : out Gtk.Enums.Gtk_Icon_Size); 
  342.  
  343.    ---------------- 
  344.    -- Interfaces -- 
  345.    ---------------- 
  346.    --  This class implements several interfaces. See Glib.Types 
  347.    -- 
  348.    --  - "Buildable" 
  349.  
  350.    package Implements_Buildable is new Glib.Types.Implements 
  351.      (Gtk.Buildable.Gtk_Buildable, Gtk_Image_Record, Gtk_Image); 
  352.    function "+" 
  353.      (Widget : access Gtk_Image_Record'Class) 
  354.    return Gtk.Buildable.Gtk_Buildable 
  355.    renames Implements_Buildable.To_Interface; 
  356.    function "-" 
  357.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  358.    return Gtk_Image 
  359.    renames Implements_Buildable.To_Object; 
  360.  
  361.    ---------------- 
  362.    -- Properties -- 
  363.    ---------------- 
  364.    --  The following properties are defined for this widget. See 
  365.    --  Glib.Properties for more information on properties) 
  366.    -- 
  367.    --  Name: File_Property 
  368.    --  Type: UTF8_String 
  369.    --  Flags: read-write 
  370.    -- 
  371.    --  Name: Gicon_Property 
  372.    --  Type: Glib.G_Icon.G_Icon 
  373.    --  Flags: read-write 
  374.    --  The GIcon displayed in the GtkImage. For themed icons, If the icon 
  375.    --  theme is changed, the image will be updated automatically. 
  376.    -- 
  377.    --  Name: Icon_Name_Property 
  378.    --  Type: UTF8_String 
  379.    --  Flags: read-write 
  380.    --  The name of the icon in the icon theme. If the icon theme is changed, 
  381.    --  the image will be updated automatically. 
  382.    -- 
  383.    --  Name: Icon_Set_Property 
  384.    --  Type: Gtk.Icon_Factory.Gtk_Icon_Set 
  385.    --  Flags: read-write 
  386.    -- 
  387.    --  Name: Icon_Size_Property 
  388.    --  Type: Gint 
  389.    --  Flags: read-write 
  390.    -- 
  391.    --  Name: Image_Property 
  392.    --  Type: Gdk.Image.Gdk_Image 
  393.    --  Flags: read-write 
  394.    -- 
  395.    --  Name: Mask_Property 
  396.    --  Type: Gdk.Pixmap.Gdk_Pixmap 
  397.    --  Flags: read-write 
  398.    -- 
  399.    --  Name: Pixbuf_Property 
  400.    --  Type: Gdk.Pixbuf.Gdk_Pixbuf 
  401.    --  Flags: read-write 
  402.    -- 
  403.    --  Name: Pixbuf_Animation_Property 
  404.    --  Type: Gdk.Pixbuf.Gdk_Pixbuf_Animation 
  405.    --  Flags: read-write 
  406.    -- 
  407.    --  Name: Pixel_Size_Property 
  408.    --  Type: Gint 
  409.    --  Flags: read-write 
  410.    --  The "pixel-size" property can be used to specify a fixed size 
  411.    --  overriding the Gtk.Image.Gtk_Image:icon-size property for images of type 
  412.    --  %GTK_IMAGE_ICON_NAME. 
  413.    -- 
  414.    --  Name: Pixmap_Property 
  415.    --  Type: Gdk.Pixmap.Gdk_Pixmap 
  416.    --  Flags: read-write 
  417.    -- 
  418.    --  Name: Stock_Property 
  419.    --  Type: UTF8_String 
  420.    --  Flags: read-write 
  421.    -- 
  422.    --  Name: Storage_Type_Property 
  423.    --  Type: Gtk_Image_Type 
  424.    --  Flags: read-write 
  425.  
  426.    File_Property : constant Glib.Properties.Property_String; 
  427.    Gicon_Property : constant Glib.Properties.Property_Boxed; 
  428.    Icon_Name_Property : constant Glib.Properties.Property_String; 
  429.    Icon_Set_Property : constant Glib.Properties.Property_Boxed; 
  430.    Icon_Size_Property : constant Glib.Properties.Property_Int; 
  431.    Image_Property : constant Glib.Properties.Property_Boxed; 
  432.    Mask_Property : constant Glib.Properties.Property_Boxed; 
  433.    Pixbuf_Property : constant Glib.Properties.Property_Object; 
  434.    Pixbuf_Animation_Property : constant Glib.Properties.Property_Boxed; 
  435.    Pixel_Size_Property : constant Glib.Properties.Property_Int; 
  436.    Pixmap_Property : constant Glib.Properties.Property_Boxed; 
  437.    Stock_Property : constant Glib.Properties.Property_String; 
  438.    Storage_Type_Property : constant Glib.Properties.Property_Boxed; 
  439.  
  440. private 
  441.    File_Property : constant Glib.Properties.Property_String := 
  442.      Glib.Properties.Build ("file"); 
  443.    Gicon_Property : constant Glib.Properties.Property_Boxed := 
  444.      Glib.Properties.Build ("gicon"); 
  445.    Icon_Name_Property : constant Glib.Properties.Property_String := 
  446.      Glib.Properties.Build ("icon-name"); 
  447.    Icon_Set_Property : constant Glib.Properties.Property_Boxed := 
  448.      Glib.Properties.Build ("icon-set"); 
  449.    Icon_Size_Property : constant Glib.Properties.Property_Int := 
  450.      Glib.Properties.Build ("icon-size"); 
  451.    Image_Property : constant Glib.Properties.Property_Boxed := 
  452.      Glib.Properties.Build ("image"); 
  453.    Mask_Property : constant Glib.Properties.Property_Boxed := 
  454.      Glib.Properties.Build ("mask"); 
  455.    Pixbuf_Property : constant Glib.Properties.Property_Object := 
  456.      Glib.Properties.Build ("pixbuf"); 
  457.    Pixbuf_Animation_Property : constant Glib.Properties.Property_Boxed := 
  458.      Glib.Properties.Build ("pixbuf-animation"); 
  459.    Pixel_Size_Property : constant Glib.Properties.Property_Int := 
  460.      Glib.Properties.Build ("pixel-size"); 
  461.    Pixmap_Property : constant Glib.Properties.Property_Boxed := 
  462.      Glib.Properties.Build ("pixmap"); 
  463.    Stock_Property : constant Glib.Properties.Property_String := 
  464.      Glib.Properties.Build ("stock"); 
  465.    Storage_Type_Property : constant Glib.Properties.Property_Boxed := 
  466.      Glib.Properties.Build ("storage-type"); 
  467. end Gtk.Image;