/src/wrappers/gtk/library/gtk_icon_theme.e
Specman e | 743 lines | 134 code | 192 blank | 417 comment | 2 complexity | 750d3ef1ed3ac199efc174fcc891857b MD5 | raw file
1indexing 2 description: "GtkIconTheme -- Looking up icons by name." 3 copyright: "[ 4 Copyright (C) 2006 Paolo Redaelli, GTK+ team 5 6 This library is free software; you can redistribute it and/or 7 modify it under the terms of the GNU Lesser General Public License 8 as published by the Free Software Foundation; either version 2.1 of 9 the License, or (at your option) any later version. 10 11 This library is distributed in the hopeOA that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 Lesser General Public License for more details. 15 16 You should have received a copy of the GNU Lesser General Public 17 License along with this library; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 02110-1301 USA 20 ]" 21 22class GTK_ICON_THEME 23 -- GtkIconTheme provides a facility for looking up icons by name 24 -- and size. The main reason for using a name rather than simply 25 -- providing a filename is to allow different icons to be used 26 -- depending on what icon theme is selecetd by the user. The 27 -- operation of icon themes on Linux and Unix follows the Icon 28 -- Theme Specification. There is a default icon theme, named 29 -- hicolor where applications should install their icons, but more 30 -- additional application themes can be installed as operating 31 -- system vendors and users choose. 32 33 -- Named icons are similar to the Themeable Stock Images(3) 34 -- facility, and the distinction between the two may be a bit 35 -- confusing. A few things to keep in mind: 36 37 -- o Stock images usually are used in conjunction with Stock 38 -- Items(3)., such as GTK_STOCK_OK or GTK_STOCK_OPEN. Named icons 39 -- are easier to set up and therefore are more useful for new icons 40 -- that an application wants to add, such as application icons or 41 -- window icons. 42 43 -- o Stock images can only be loaded at the symbolic sizes defined 44 -- by the GtkIconSize enumeration, or by custom sizes defined by 45 -- gtk_icon_size_register(), while named icons are more flexible 46 -- and any pixel size can be specified. 47 48 -- o Because stock images are closely tied to stock items, and thus 49 -- to actions in the user interface, stock images may come in 50 -- multiple variants for different widget states or writing 51 -- directions. 52 53 -- A good rule of thumb is that if there is a stock image for what 54 -- you want to use, use it, otherwise use a named icon. It turns 55 -- out that internally stock images are generally defined in terms 56 -- of one or more named icons. (An example of the more than one 57 -- case is icons that depend on writing direction; 58 -- GTK_STOCK_GO_FORWARD uses the two themed icons 59 -- "gtk-stock-go-forward-ltr" and "gtk-stock-go-forward-rtl".) 60 61 -- In many cases, named themes are used indirectly, via GtkImage or 62 -- stock items, rather than directly, but looking up icons directly 63 -- is also simple. The GtkIconTheme object acts as a database of 64 -- all the icons in the current theme. You can create new 65 -- GtkIconTheme objects, but its much more efficient to use the 66 -- standard icon theme for the GdkScreen so that the icon 67 -- information is shared with other people looking up icons. In the 68 -- case where the default screen is being used, looking up an icon 69 -- can be as simple as: (TODO: Eiffelize example) 70 71 -- GError *error = NULL; 72 -- GtkIconTheme *icon_theme; 73 -- GdkPixbuf *pixbuf; 74 75 -- icon_theme = gtk_icon_theme_get_default(); pixbuf = 76 -- gtk_icon_theme_load_icon (icon_theme, "my-icon-name", /* 77 -- icon name */ 48, /* size */ 0, /* flags */ &error); if 78 -- (!pixbuf) { g_warning ("Couldn't load icon: %s", 79 -- error->message); g_error_free (error); } else { /* Use the 80 -- pixbuf */ g_object_unref (pixbuf); } 81 82inherit 83 G_OBJECT 84 85insert 86 GTK_ICON_LOOKUP_FLAGS 87 88 -- TODO: enum GtkIconThemeError; 89 90creation make, from_external_pointer 91 92feature {} -- Creation 93 94 make is 95 -- Creates a new icon theme object. Icon theme objects are 96 -- used to lookup up an icon by name in a particular icon 97 -- theme. Usually, you'll want to use `default' or 98 -- `from_screen' rather than creating a new icon theme object 99 -- for scratch. 100 do 101 from_external_pointer(gtk_icon_theme_new) 102 end 103 104 from_screen (a_screen: GDK_SCREEN) is 105 -- the icon theme object associated with `a_screen'; if this 106 -- function has not previously been called for the given 107 -- screen, a new icon theme object will be created and 108 -- associated with the screen. Icon theme objects are fairly 109 -- expensive to create, so using this function is usually a 110 -- better choice than calling than `make' and setting the 111 -- screen yourself; by using this function a single icon 112 -- theme object will be shared between users. 113 114 -- A unique GtkIconTheme associated with the given 115 -- screen. This icon theme is associated with the screen and 116 -- can be used as long as the screen is open. Do not ref or 117 -- unref it. 118 require screen_not_void: a_screen /= Void 119 do 120 handle := gtk_icon_theme_get_for_screen (a_screen.handle) 121 store_eiffel_wrapper 122 end 123 124feature 125 set_screen (a_screen: GDK_SCREEN) is 126 -- Sets `a_screen' for an icon theme; the screen is used to 127 -- track the user's currently configured icon theme, which 128 -- might be different for different screens. 129 require screen_not_void: a_screen /= Void 130 do 131 gtk_icon_theme_set_screen (handle, a_screen.handle) 132 end 133 134 set_search_path (some_path: STRING_ARRAY) is 135 -- Sets the search path for the icon theme object. When 136 -- looking for an icon theme, GTK+ will search for a 137 -- subdirectory of one or more of the directories in path 138 -- with the same name as the icon theme. (Themes from 139 -- multiple of the path elements are combined to allow themes 140 -- to be extended by adding icons in the user's home 141 -- directory.) 142 143 -- In addition if an icon found isn't found either in the 144 -- current icon theme or the default icon theme, and an image 145 -- file with the right name is found directly in one of the 146 -- elements of path, then that image will be used for the 147 -- icon name. (This is legacy feature, and new icons should 148 -- be put into the default icon theme, which is called 149 -- DEFAULT_THEME_NAME, rather than directly on the icon 150 -- path.) 151 152 -- `some_path': array of directories that are searched for 153 -- icon themes 154 do 155 gtk_icon_theme_set_search_path (handle, some_path.storage.to_pointer, some_path.count) 156 end 157 158 -- search_path: 159 160-- void gtk_icon_theme_get_search_path (GtkIconTheme *icon_theme, 161-- gchar **path[], 162-- gint *n_elements); 163 164-- Gets the current search path. See gtk_icon_theme_set_search_path(). 165 166-- icon_theme : a GtkIconTheme 167-- path : location to store a list of icon theme path directories or 168-- NULL The stored value should be freed with g_strfreev(). 169-- n_elements : location to store number of elements in path, or NULL 170 171-- Since 2.4 172 173-- -------------------------------------------------------------------------- 174 175-- gtk_icon_theme_append_search_path () 176 177-- void gtk_icon_theme_append_search_path 178-- (GtkIconTheme *icon_theme, 179-- const gchar *path); 180 181-- Appends a directory to the search path. See 182-- gtk_icon_theme_set_search_path(). 183 184-- icon_theme : a GtkIconTheme 185-- path : directory name to append to the icon path 186 187-- Since 2.4 188 189-- -------------------------------------------------------------------------- 190 191-- gtk_icon_theme_prepend_search_path () 192 193-- void gtk_icon_theme_prepend_search_path 194-- (GtkIconTheme *icon_theme, 195-- const gchar *path); 196 197-- Prepends a directory to the search path. See 198-- gtk_icon_theme_set_search_path(). 199 200-- icon_theme : a GtkIconTheme 201-- path : directory name to prepend to the icon path 202 203-- Since 2.4 204 205-- -------------------------------------------------------------------------- 206 207-- gtk_icon_theme_set_custom_theme () 208 209-- void gtk_icon_theme_set_custom_theme (GtkIconTheme *icon_theme, 210-- const gchar *theme_name); 211 212-- Sets the name of the icon theme that the GtkIconTheme object uses 213-- overriding system configuration. This function cannot be called on the 214-- icon theme objects returned from gtk_icon_theme_get_default() and 215-- gtk_icon_theme_get_for_screen(). 216 217-- icon_theme : a GtkIconTheme 218-- theme_name : name of icon theme to use instead of configured theme, or 219-- NULL to unset a previously set custom theme 220 221-- Since 2.4 222 223-- -------------------------------------------------------------------------- 224 225-- gtk_icon_theme_has_icon () 226 227-- gboolean gtk_icon_theme_has_icon (GtkIconTheme *icon_theme, 228-- const gchar *icon_name); 229 230-- Checks whether an icon theme includes an icon for a particular name. 231 232-- icon_theme : a GtkIconTheme 233-- icon_name : the name of an icon 234-- Returns : TRUE if icon_theme includes an icon for icon_name. 235 236-- Since 2.4 237 238-- -------------------------------------------------------------------------- 239 240-- gtk_icon_theme_lookup_icon () 241 242-- GtkIconInfo* gtk_icon_theme_lookup_icon (GtkIconTheme *icon_theme, 243-- const gchar *icon_name, 244-- gint size, 245-- GtkIconLookupFlags flags); 246 247-- Looks up a named icon and returns a structure containing information such 248-- as the filename of the icon. The icon can then be rendered into a pixbuf 249-- using gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines 250-- these two steps if all you need is the pixbuf.) 251 252-- icon_theme : a GtkIconTheme 253-- icon_name : the name of the icon to lookup 254-- size : desired icon size 255-- flags : flags modifying the behavior of the icon lookup 256-- Returns : a GtkIconInfo structure containing information about the 257-- icon, or NULL if the icon wasn't found. Free with 258-- gtk_icon_info_free() 259 260-- Since 2.4 261 262-- -------------------------------------------------------------------------- 263 264-- gtk_icon_theme_load_icon () 265 266-- GdkPixbuf* gtk_icon_theme_load_icon (GtkIconTheme *icon_theme, 267-- const gchar *icon_name, 268-- gint size, 269-- GtkIconLookupFlags flags, 270-- GError **error); 271 272-- Looks up an icon in an icon theme, scales it to the given size and renders 273-- it into a pixbuf. This is a convenience function; if more details about 274-- the icon are needed, use gtk_icon_theme_lookup_icon() followed by 275-- gtk_icon_info_load_icon(). 276 277-- Note that you probably want to listen for icon theme changes and update 278-- the icon. This is usually done by connecting to the GtkWidget::style-set 279-- signal. If for some reason you do not want to update the icon when the 280-- icon theme changes, you should consider using gdk_pixbuf_copy() to make a 281-- private copy of the pixbuf returned by this function. Otherwise GTK+ may 282-- need to keep the old icon theme loaded, which would be a waste of memory. 283 284-- icon_theme : a GtkIconTheme 285-- icon_name : the name of the icon to lookup 286-- size : the desired icon size. The resulting icon may not be exactly 287-- this size; see gtk_icon_info_load_icon(). 288-- flags : flags modifying the behavior of the icon lookup 289-- error : Location to store error information on failure, or NULL. 290-- Returns : the rendered icon; this may be a newly created icon or a new 291-- reference to an internal icon, so you must not modify the 292-- icon. Use g_object_unref() to release your reference to the 293-- icon. NULL if the icon isn't found. 294 295-- Since 2.4 296 297-- -------------------------------------------------------------------------- 298 299-- gtk_icon_theme_list_icons () 300 301-- GList* gtk_icon_theme_list_icons (GtkIconTheme *icon_theme, 302-- const gchar *context); 303 304-- Lists the icons in the current icon theme. Only a subset of the icons can 305-- be listed by providing a context string. The set of values for the context 306-- string is system dependent, but will typically include such values as 307-- "Applications" and "MimeTypes". 308 309-- icon_theme : a GtkIconTheme 310-- context : a string identifying a particular type of icon, or NULL to 311-- list all icons. 312-- Returns : a GList list holding the names of all the icons in the theme. 313-- You must first free each element in the list with g_free(), 314-- then free the list itself with g_list_free(). 315 316-- Since 2.4 317 318-- -------------------------------------------------------------------------- 319 320-- gtk_icon_theme_get_icon_sizes () 321 322-- gint* gtk_icon_theme_get_icon_sizes (GtkIconTheme *icon_theme, 323-- const gchar *icon_name); 324 325-- Returns an array of integers describing the sizes at which the icon is 326-- available without scaling. A size of -1 means that the icon is available 327-- in a scalable format. The array is zero-terminated. 328 329-- icon_theme : a GtkIconTheme 330-- icon_name : the name of an icon 331-- Returns : An newly allocated array describing the sizes at which the 332-- icon is available. The array should be freed with g_free() 333-- when it is no longer needed. 334 335-- Since 2.6 336 337-- -------------------------------------------------------------------------- 338 339-- gtk_icon_theme_get_example_icon_name () 340 341-- char* gtk_icon_theme_get_example_icon_name 342-- (GtkIconTheme *icon_theme); 343 344-- Gets the name of an icon that is representative of the current theme (for 345-- instance, to use when presenting a list of themes to the user.) 346 347-- icon_theme : a GtkIconTheme 348-- Returns : the name of an example icon or NULL. Free with g_free(). 349 350-- Since 2.4 351 352-- -------------------------------------------------------------------------- 353 354-- gtk_icon_theme_rescan_if_needed () 355 356-- gboolean gtk_icon_theme_rescan_if_needed (GtkIconTheme *icon_theme); 357 358-- Checks to see if the icon theme has changed; if it has, any currently 359-- cached information is discarded and will be reloaded next time icon_theme 360-- is accessed. 361 362-- icon_theme : a GtkIconTheme 363-- Returns : TRUE if the icon theme has changed and needed to be reloaded. 364 365-- Since 2.4 366 367-- -------------------------------------------------------------------------- 368 369-- gtk_icon_theme_add_builtin_icon () 370 371-- void gtk_icon_theme_add_builtin_icon (const gchar *icon_name, 372-- gint size, 373-- GdkPixbuf *pixbuf); 374 375-- Registers a built-in icon for icon theme lookups. The idea of built-in 376-- icons is to allow an application or library that uses themed icons to 377-- function requiring files to be present in the file system. For instance, 378-- the default images for all of GTK+'s stock icons are registered as 379-- built-icons. 380 381-- In general, if you use gtk_icon_theme_add_builtin_icon() you should also 382-- install the icon in the icon theme, so that the icon is generally 383-- available. 384 385-- This function will generally be used with pixbufs loaded via 386-- gdk_pixbuf_new_from_inline(). 387 388-- icon_name : the name of the icon to register 389-- size : the size at which to register the icon (different images can 390-- be registered for the same icon name at different sizes.) 391-- pixbuf : GdkPixbuf that contains the image to use for icon_name. 392 393-- Since 2.4 394 395-- -------------------------------------------------------------------------- 396 397-- gtk_icon_info_copy () 398 399-- GtkIconInfo* gtk_icon_info_copy (GtkIconInfo *icon_info); 400 401-- Make a copy of a GtkIconInfo. 402 403-- icon_info : a GtkIconInfo 404-- Returns : the new GtkIconInfo 405 406-- Since 2.4 407 408-- -------------------------------------------------------------------------- 409 410-- gtk_icon_info_free () 411 412-- void gtk_icon_info_free (GtkIconInfo *icon_info); 413 414-- Free a GtkIconInfo and associated information 415 416-- icon_info : a GtkIconInfo 417 418-- Since 2.4 419 420-- -------------------------------------------------------------------------- 421 422-- gtk_icon_info_get_base_size () 423 424-- gint gtk_icon_info_get_base_size (GtkIconInfo *icon_info); 425 426-- Gets the base size for the icon. The base size is a size for the icon that 427-- was specified by the icon theme creator. This may be different than the 428-- actual size of image; an example of this is small emblem icons that can be 429-- attached to a larger icon. These icons will be given the same base size as 430-- the larger icons to which they are attached. 431 432-- icon_info : a GtkIconInfo 433-- Returns : the base size, or 0, if no base size is known for the icon. 434 435-- Since 2.4 436 437-- -------------------------------------------------------------------------- 438 439-- gtk_icon_info_get_filename () 440 441-- const gchar* gtk_icon_info_get_filename (GtkIconInfo *icon_info); 442 443-- Gets the filename for the icon. If the GTK_ICON_LOOKUP_USE_BUILTIN flag 444-- was passed to gtk_icon_theme_lookup_icon(), there may be no filename if a 445-- builtin icon is returned; in this case, you should use 446-- gtk_icon_info_get_builtin_pixbuf(). 447 448-- icon_info : a GtkIconInfo 449-- Returns : the filename for the icon, or NULL if 450-- gtk_icon_info_get_builtin_pixbuf() should be used instead. The 451-- return value is owned by GTK+ and should not be modified or 452-- freed. 453 454-- Since 2.4 455 456-- -------------------------------------------------------------------------- 457 458-- gtk_icon_info_get_builtin_pixbuf () 459 460-- GdkPixbuf* gtk_icon_info_get_builtin_pixbuf 461-- (GtkIconInfo *icon_info); 462 463-- Gets the built-in image for this icon, if any. To allow GTK+ to use built 464-- in icon images, you must pass the GTK_ICON_LOOKUP_USE_BUILTIN to 465-- gtk_icon_theme_lookup_icon(). 466 467-- icon_info : a GtkIconInfo structure 468-- Returns : the built-in image pixbuf, or NULL. No extra reference is 469-- added to the returned pixbuf, so if you want to keep it 470-- around, you must use g_object_ref(). The returned image must 471-- not be modified. 472 473-- Since 2.4 474 475-- -------------------------------------------------------------------------- 476 477-- gtk_icon_info_load_icon () 478 479-- GdkPixbuf* gtk_icon_info_load_icon (GtkIconInfo *icon_info, 480-- GError **error); 481 482-- Renders an icon previously looked up in an icon theme using 483-- gtk_icon_theme_lookup_icon(); the size will be based on the size passed to 484-- gtk_icon_theme_lookup_icon(). Note that the resulting pixbuf may not be 485-- exactly this size; an icon theme may have icons that differ slightly from 486-- their nominal sizes, and in addition GTK+ will avoid scaling icons that it 487-- considers sufficiently close to the requested size or for which the source 488-- image would have to be scaled up too far. (This maintains sharpness.) 489 490-- icon_info : a GtkIconInfo structure from gtk_icon_theme_lookup_icon() 491-- error : location to store error information on failure, or NULL. 492-- Returns : the rendered icon; this may be a newly created icon or a new 493-- reference to an internal icon, so you must not modify the 494-- icon. Use g_object_unref() to release your reference to the 495-- icon. 496 497-- Since 2.4 498 499-- -------------------------------------------------------------------------- 500 501-- gtk_icon_info_set_raw_coordinates () 502 503-- void gtk_icon_info_set_raw_coordinates 504-- (GtkIconInfo *icon_info, 505-- gboolean raw_coordinates); 506 507-- Sets whether the coordinates returned by gtk_icon_info_get_embedded_rect() 508-- and gtk_icon_info_get_attach_points() should be returned in their original 509-- form as specified in the icon theme, instead of scaled appropriately for 510-- the pixbuf returned by gtk_icon_info_load_icon(). 511 512-- Raw coordinates are somewhat strange; they are specified to be with 513-- respect to the unscaled pixmap for PNG and XPM icons, but for SVG icons, 514-- they are in a 1000x1000 coordinate space that is scaled to the final size 515-- of the icon. You can determine if the icon is an SVG icon by using 516-- gtk_icon_info_get_filename(), and seeing if it is non-NULL and ends in 517-- '.svg'. 518 519-- This function is provided primarily to allow compatibility wrappers for 520-- older API's, and is not expected to be useful for applications. 521 522-- icon_info : a GtkIconInfo 523-- raw_coordinates : whether the coordinates of embedded rectangles and 524-- attached points should be returned in their original 525-- (unscaled) form. 526 527-- Since 2.4 528 529-- -------------------------------------------------------------------------- 530 531-- gtk_icon_info_get_embedded_rect () 532 533-- gboolean gtk_icon_info_get_embedded_rect (GtkIconInfo *icon_info, 534-- GdkRectangle *rectangle); 535 536-- Gets the coordinates of a rectangle within the icon that can be used for 537-- display of information such as a preview of the contents of a text file. 538-- See gtk_icon_info_set_raw_coordinates() for further information about the 539-- coordinate system. 540 541-- icon_info : a GtkIconInfo 542-- rectangle : GdkRectangle in which to store embedded rectangle coordinates; 543-- coordinates are only stored when this function returns TRUE. 544-- Returns : TRUE if the icon has an embedded rectangle 545 546-- Since 2.4 547 548-- -------------------------------------------------------------------------- 549 550-- gtk_icon_info_get_attach_points () 551 552-- gboolean gtk_icon_info_get_attach_points (GtkIconInfo *icon_info, 553-- GdkPoint **points, 554-- gint *n_points); 555 556-- Fetches the set of attach points for an icon. An attach point is a 557-- location in the icon that can be used as anchor points for attaching 558-- emblems or overlays to the icon. 559 560-- icon_info : a GtkIconInfo 561-- points : location to store pointer to an array of points, or NULL free 562-- the array of points with g_free(). 563-- n_points : location to store the number of points in points, or NULL 564-- Returns : TRUE if there are any attach points for the icon. 565 566-- Since 2.4 567 568-- -------------------------------------------------------------------------- 569 570-- gtk_icon_info_get_display_name () 571 572-- const gchar* gtk_icon_info_get_display_name (GtkIconInfo *icon_info); 573 574-- Gets the display name for an icon. A display name is a string to be used 575-- in place of the icon name in a user visible context like a list of icons. 576 577-- icon_info : a GtkIconInfo 578-- Returns : the display name for the icon or NULL, if the icon doesn't 579-- have a specified display name. This value is owned icon_info 580-- and must not be modified or free. 581 582-- Since 2.4 583 584feature -- The "changed" signal 585 586-- void user_function (GtkIconTheme *icon_theme, 587-- gpointer user_data) : Run last 588 589-- Emitted when the current icon theme is switched or GTK+ detects that a 590-- change has occurred in the contents of the current icon theme. 591 592-- icon_theme : the icon theme 593 594feature -- size 595 struct_size: INTEGER is 596 external "C inline use <gtk/gtk.h>" 597 alias "sizeof(GtkIconTheme)" 598 end 599 600feature {} -- External calls 601 gtk_icon_theme_error: INTEGER is 602 -- The GQuark used for GtkIconThemeError errors. 603 external "C macro <gtk/gtk.h>" 604 alias "GTK_ICON_THEME_ERROR" 605 end 606 607 gtk_icon_theme_new: POINTER is 608 -- GtkIconTheme* gtk_icon_theme_new (void); 609 external "C use <gtk/gtk.h>" 610 end 611 612 gtk_icon_theme_get_for_screen (a_screen: POINTER): POINTER is 613 -- GtkIconTheme* gtk_icon_theme_get_for_screen (GdkScreen *screen); 614 external "C use <gtk/gtk.h>" 615 end 616 617 gtk_icon_theme_set_screen (an_icon_theme, a_screen: POINTER) is 618 -- void gtk_icon_theme_set_screen (GtkIconTheme *icon_theme, GdkScreen *screen); 619 external "C use <gtk/gtk.h>" 620 end 621 622 gtk_icon_theme_set_search_path (an_icon_theme, a_path: POINTER; an_elements_n: INTEGER) is 623 -- void gtk_icon_theme_set_search_path (GtkIconTheme 624 -- *icon_theme, const gchar *path[], gint n_elements); 625 external "C use <gtk/gtk.h>" 626 end 627 628 gtk_icon_theme_get_search_path (an_icon_theme, some_paths, a_n_element: POINTER) is 629 -- void gtk_icon_theme_get_search_path (GtkIconTheme 630 -- *icon_theme, gchar **path[], gint *n_elements); 631 external "C use <gtk/gtk.h>" 632 end 633 634 gtk_icon_theme_append_search_path (an_icon_theme, a_path: POINTER) is 635 -- void gtk_icon_theme_append_search_path (GtkIconTheme *icon_theme, const gchar *path); 636 external "C use <gtk/gtk.h>" 637 end 638 639 gtk_icon_theme_prepend_search_path (an_icon_theme, a_path: POINTER) is 640 -- void gtk_icon_theme_prepend_search_path (GtkIconTheme 641 -- *icon_theme, const gchar *path); 642 external "C use <gtk/gtk.h>" 643 end 644 645 gtk_icon_theme_set_custom_theme (an_icon_theme, a_theme_name: POINTER) is 646 -- void gtk_icon_theme_set_custom_theme (GtkIconTheme 647 -- *icon_theme, const gchar *theme_name); 648 external "C use <gtk/gtk.h>" 649 end 650 651 gtk_icon_theme_has_icon (an_icon_theme, an_icon_name: POINTER): INTEGER is 652 -- gboolean gtk_icon_theme_has_icon (GtkIconTheme *icon_theme, const gchar *icon_name); 653 external "C use <gtk/gtk.h>" 654 end 655 656 gtk_icon_theme_lookup_icon (an_icon_theme, an_icon_name: POINTER; a_size, some_flags: INTEGER): POINTER is 657 -- GtkIconInfo* gtk_icon_theme_lookup_icon (GtkIconTheme *icon_theme, const gchar *icon_name, gint size, GtkIconLookupFlags flags); 658 external "C use <gtk/gtk.h>" 659 end 660 661 gtk_icon_theme_load_icon (an_icon_theme, an_icon_name: POINTER; a_size, some_flags: INTEGER; error_handle: POINTER): POINTER is 662 -- GdkPixbuf* gtk_icon_theme_load_icon (GtkIconTheme *icon_theme, const gchar *icon_name, gint size, GtkIconLookupFlags flags, GError **error); 663 external "C use <gtk/gtk.h>" 664 end 665 666 gtk_icon_theme_list_icons (an_icon_theme, a_context: POINTER): POINTER is 667 -- GList* gtk_icon_theme_list_icons (GtkIconTheme *icon_theme, const gchar *context); 668 external "C use <gtk/gtk.h>" 669 end 670 671 gtk_icon_theme_get_icon_sizes (an_icon_theme, an_icon_name: POINTER): POINTER is 672 -- gint* gtk_icon_theme_get_icon_sizes (GtkIconTheme 673 -- *icon_theme, const gchar *icon_name); 674 external "C use <gtk/gtk.h>" 675 end 676 677 gtk_icon_theme_get_example_icon_name (an_icon_theme: POINTER): POINTER is 678 -- char* gtk_icon_theme_get_example_icon_name (GtkIconTheme *icon_theme); 679 external "C use <gtk/gtk.h>" 680 end 681 682 gtk_icon_theme_rescan_if_needed (an_icon_theme: POINTER): INTEGER is 683 -- gboolean gtk_icon_theme_rescan_if_needed (GtkIconTheme *icon_theme); 684 external "C use <gtk/gtk.h>" 685 end 686 687 gtk_icon_theme_add_builtin_icon (an_icon_name: POINTER; a_size: INTEGER; a_pixbuf: POINTER) is 688 -- void gtk_icon_theme_add_builtin_icon (const gchar 689 -- *icon_name, gint size, GdkPixbuf *pixbuf); 690 external "C use <gtk/gtk.h>" 691 end 692 693 gtk_icon_info_copy (an_icon_info: POINTER): POINTER is 694 -- GtkIconInfo* gtk_icon_info_copy (GtkIconInfo *icon_info); 695 external "C use <gtk/gtk.h>" 696 end 697 698 gtk_icon_info_free (a_icon_info: POINTER) is 699 -- void gtk_icon_info_free (GtkIconInfo *icon_info); 700 external "C use <gtk/gtk.h>" 701 end 702 703 gtk_icon_info_get_base_size (a_icon_info: POINTER): INTEGER is 704 -- gint gtk_icon_info_get_base_size (GtkIconInfo *icon_info); 705 external "C use <gtk/gtk.h>" 706 end 707 708 gtk_icon_info_get_filename (a_icon_info: POINTER): POINTER is 709 -- const gchar* gtk_icon_info_get_filename (GtkIconInfo *icon_info); 710 external "C use <gtk/gtk.h>" 711 end 712 713 gtk_icon_info_get_builtin_pixbuf (a_icon_info: POINTER): POINTER is 714 -- GdkPixbuf* gtk_icon_info_get_builtin_pixbuf (GtkIconInfo *icon_info); 715 external "C use <gtk/gtk.h>" 716 end 717 718 gtk_icon_info_load_icon (a_icon_info, an_error_handle: POINTER): POINTER is 719 -- GdkPixbuf* gtk_icon_info_load_icon (GtkIconInfo *icon_info, GError **error); 720 external "C use <gtk/gtk.h>" 721 end 722 723 gtk_icon_info_set_raw_coordinates (a_icon_info: POINTER; raw_coordinates_bool: INTEGER) is 724 -- void gtk_icon_info_set_raw_coordinates (GtkIconInfo 725 -- *icon_info, gboolean raw_coordinates); 726 external "C use <gtk/gtk.h>" 727 end 728 729 gtk_icon_info_get_embedded_rect (a_icon_info, a_rectangle: POINTER): INTEGER is 730 -- gboolean gtk_icon_info_get_embedded_rect (GtkIconInfo *icon_info, GdkRectangle *rectangle); 731 external "C use <gtk/gtk.h>" 732 end 733 734 gtk_icon_info_get_attach_points (a_icon_info, a_points_handle, a_n_points: POINTER): INTEGER is 735 -- gboolean gtk_icon_info_get_attach_points (GtkIconInfo *icon_info, GdkPoint **points, gint *n_points); 736 external "C use <gtk/gtk.h>" 737 end 738 739 gtk_icon_info_get_display_name (a_icon_info: POINTER): POINTER is 740 -- const gchar* gtk_icon_info_get_display_name (GtkIconInfo *icon_info); 741 external "C use <gtk/gtk.h>" 742 end 743end