Left side insert a widget to a box. The expand argument to pack_start() or pack_end() controls whether the widgets are laid out in the box to fill in all the extra space in the box so the box is expanded to fill the area allocated to it (%TRUE). Or the box is shrunk to just fit the widgets (%FALSE). Setting @expand to %FALSE will allow you to do right and left justifying of your widgets. Otherwise, they will all expand to fit in the box, and the same effect could be achieved by using only one of pack_start() or pack_end() functions. The @fill argument to the pack_start()/pack_end() functions control whether the extra space is allocated to the objects themselves (%TRUE), or as extra padding in the box around these objects (%FALSE). It only has an effect if the @expand argument is also %TRUE. The difference between spacing (set when the box is created) and padding (set when elements are packed) is, that spacing is added between objects, and padding is added on either side of an object. Obtains a copy of the default text attributes. These are the attributes used for text unless a tag overrides them. You'd typically pass the default attributes in to Gtk::TextIter::get_attributes() in order to get the attributes in effect at a given text position. a #GtkTextView a new #Gtk::TextAttributes Fetches the text from a label widget including any embedded underlines indicating mnemonics and Pango markup. (See get_text ()). a #GtkLabel the text of the label widget.. Fetches the text from a label widget, as displayed on the screen. This does not include any embedded underlines indicating mnemonics or Pango markup. (See get_label()) a #GtkLabel the text in the label widget. Gets the #PangoLayout used to display the label. The layout is useful to e.g. convert text positions to pixel positions, in combination with gtk_label_get_layout_offsets(). a #GtkLabel the #PangoLayout for this label Retrieves the text of the tab label for the page containing @child. a #GtkNotebook a widget contained in a page of @notebook value: the text of the tab label. Retrieves the text of the menu label for the page containing @child. a #GtkNotebook the child widget of a page of the notebook. value: the text of the tab label. Creates a mark at position @where. The mark can be retrieved by name using gtk_text_buffer_get_mark (). If a mark has left gravity, and text is inserted at the mark's current location, the mark will be moved to the left of the newly-inserted text. If the mark has right gravity (@left_gravity = %FALSE), the mark will end up on the right of newly-inserted text. The standard left-to-right cursor is a mark with right gravity (when you type, the cursor stays on the right side of the text you're typing). Emits the "mark_set" signal as notification of the mark's initial placement. a #GtkTextBuffer name for mark, or %NULL location to place mark whether the mark has left gravity the new #GtkTextMark object Deletes @mark, so that it's no longer located anywhere in the buffer. Removes the reference the buffer holds to the mark, so if you don't keep a Glib::RefPtr to the mark, it will be freed. Even if the mark isn't freed, most operations on @mark become invalid. There is no way to undelete a mark. gtk_text_mark_get_deleted () will return TRUE after this function has been called on a mark; gtk_text_mark_get_deleted () indicates that a mark no longer belongs to a buffer. The "mark_deleted" signal will be emitted as notification after the mark is deleted. a #GtkTextBuffer a #GtkTextMark in @buffer Returns a list of tags that apply to @iter, in ascending order of priority (highest-priority tags are last). a #GtkTextIter list of #GtkTextTag Gets the default tabs for @text_view. Tags in the buffer may override the defaults. The returned array will be empty if "standard" (8-space) tabs are used. a #GtkTextView copy of default tab array, or an empty array if "standard" tabs are used. Blocks in a recursive main loop until the @dialog emits the response signal. It returns the response ID from the "response" signal emission. Before entering the recursive main loop, gtk_dialog_run() calls Gtk::Widget::show() on the dialog for you. Note that you still need to show any children of the dialog yourself. If the dialog receives "delete_event", Gtk::Dialog::run() will return #GTK_RESPONSE_DELETE_EVENT. Also, during Gtk::Dialog::run() the dialog will be modal. You can force Gtk::Dialog::run() to return at any time by calling Gtk::Dialog::response() to emit the "response" signal. After Gtk::Dialog::run() returns, you are responsible for hiding or destroying the dialog if you wish to do so. Typical usage of this function might be: <informalexample><programlisting> gint result = dialog.run(); switch (result) { case GTK_RESPONSE_ACCEPT: do_application_specific_something (<!-- -->); break; default: do_nothing_since_dialog_was_cancelled (<!-- -->); break; } </programlisting></informalexample> a #GtkDialog response ID Sets the widget to be monitored by this accelerator label. Ignored :) The Widget to be monitored. Gets the width needed to display this accelerator label. This is used by menus to align all of the Gtk::MenuItem widgets, and shouldn't be needed by applications. width of this accelerator label. Recreates the string representing the accelerator keys. always returns %FALSE. Emits a "changed" signal from the Adjustment. This is typically called by the owner of the Adjustment after it has changed any of the Adjustment fields other than the value. Emits a "value_changed" signal from the Adjustment. This is typically called by the owner of the Adjustment after it has changed the Adjustment value field. Updates the Adjustment value to ensure that the range between the parameters @lower and @upper is in the current page (i.e. between @value and @value + @page_size). If this range is larger than the page size, then only the start of it will be in the current page. A "changed" signal will be emitted if the value is changed. Ignored :) The upper value. The lower value. Sets the current value of the Adjustment Ignored :) The new value of the Adjustment Sets the Alignment values. Ignored :) The horizontal alignment of the child of this Alignment, from 0 (left) to 1 (right). The vertical alignment of the child of this Alignment, from 0 (top) to 1 (bottom). The amount that the child expands horizontally to fill up unused space, from 0 to 1. A value of 0 indicates that the child widget should never expand. A value of 1 indicates that the child widget will expand to fill all the space allocated for the Alignment. The amount that the child widget expands vertically to fill up unused space from 0 to 1. The values are similar to @xscale. Sets the direction and shadow of this Arrow. Ignored :) A Gtk::ArrowType enum describing what arrow type to set this Arrow to. A Gtk::ShadowType enum describing what shadow type to set this Arrow to. Gets a list of all widgets anchored at this child anchor. a #GtkTextChildAnchor list of widgets anchored at @anchor Returns a #GtkTreePath referenced by @iter. A #GtkTreeModel. The #GtkTreeIter. a #GtkTreePath. Returns a list of all the cell renderers in the column, in no particular order. A #GtkTreeViewColumn A list of #GtkCellRenderers Returns a list of all the #GtkTreeViewColumn s currently in @tree_view. A #GtkTreeView A list of #GtkTreeViewColumn s Gets the value set by Gtk::Window::set_default_icon_list(). copy of default icon list The default widget is the widget that's activated when the user presses Enter in a dialog (for example). This function sets or unsets the default widget for a #GtkWindow. When setting (rather than unsetting) the default widget it's generally easier to call gtk_widget_grab_focus() on the widget. Before making a widget the default widget, you must set the #GTK_CAN_DEFAULT flag on the widget you'd like to make the default using Gtk::Widget::set_flags(). a #GtkWindow widget to be the default. Set the accelerator path on @menu_item, through which runtime changes of the menu item's accelerator caused by the user can be identified and saved to persistant storage (see gtk_accel_map_save() on this). To setup a default accelerator for this menu item, call gtk_accel_map_add_entry() with the same @accel_path. See also gtk_accel_map_add_entry() on the specifics of accelerator paths, and gtk_menu_set_accel_path() for a more convenient variant of this function. This function is basically a convenience wrapper that handles calling gtk_widget_set_accel_path() with the appropriate accelerator group for the menu item. Note that you do need to set an accelerator on the parent menu with gtk_menu_set_accel_group() for this to work. a valid #GtkMenuItem accelerator path, corresponding to this menu item's functionality. Appends a page to @notebook. a #GtkNotebook the #GtkWidget to use as the contents of the page. the #GtkWidget to be used as the label for the page. Appends a page to @notebook, specifying the widget to use as the label in the popup menu. a #GtkNotebook the #GtkWidget to use as the contents of the page. the #GtkWidget to be used as the label for the page. the widget to use as a label for the page-switch menu. Insert a page into @notebook at the given position a #GtkNotebook the #GtkWidget to use as the contents of the page. the #GtkWidget to be used as the label for the page. the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages. Insert a page into @notebook at the given position, specifying the widget to use as the label in the popup menu. a #GtkNotebook the #GtkWidget to use as the contents of the page. the #GtkWidget to be used as the label for the page.. the widget to use as a label for the page-switch menu. the index (starting at 0) at which to insert the page, or -1 to append the page after all other pages. Prepends a page to @notebook. a #GtkNotebook the #GtkWidget to use as the contents of the page. the #GtkWidget to be used as the label for the page. Prepends a page to @notebook, specifying the widget to use as the label in the popup menu. a #GtkNotebook the #GtkWidget to use as the contents of the page. the #GtkWidget to be used as the label for the page. the widget to use as a label for the page-switch menu. Fills the bounding rectangle in tree window coordinates for the cell at the row specified by @path and the column specified by @column. The returned rectangle is equivalent to the @background_area passed to gtk_cell_renderer_render(). These background areas tile to cover the entire tree window (except for the area used for header buttons). Contrast with the @cell_area, returned by gtk_tree_view_get_cell_area(), which returns only the cell itself, excluding surrounding borders and the tree expander area. a #GtkTreeView a #GtkTreePath for the row. a #GtkTreeViewColumn for the column. rectangle to fill with cell background rect Fills the bounding rectangle in tree window coordinates for the cell at the row specified by @path and the column specified by @column. If @path points to a path not currently displayed, the @y and @height fields of the rectangle will be filled with 0. The sum of all cell rects does not cover the entire tree; there are extra pixels in between rows, for example. The returned rectangle is equivalent to the @cell_area passed to gtk_cell_renderer_render(). This function is only valid if #tree_view is realized. a #GtkTreeView a #GtkTreePath for the row. a #GtkTreeViewColumn for the column. rectangle to fill with cell rect Sets the base color for a widget in a particular state. All other style values are left untouched. The base color is the background color used along with the text color (see gtk_widget_modify_text()) for widgets such as #GtkEntry and #GtkTextView. See also gtk_widget_modify_style(). a #GtkWidget. the state for which to set the base color. the color to assign (does not need to be allocated). Sets the background color for a widget in a particular state. All other style values are left untouched. See also gtk_widget_modify_style(). a #GtkWidget. the state for which to set the background color. the color to assign (does not need to be allocated). Sets the foreground color for a widget in a particular state. All other style values are left untouched. See also gtk_widget_modify_style(). a #GtkWidget. the state for which to set the foreground color. the color to assign (does not need to be allocated). Sets the font to use for a widget. All other style values are left untouched. See also gtk_widget_modify_style(). a #GtkWidget the font description to use. Sets the text color for a widget in a particular state. All other style values are left untouched. The text color is the foreground color used along with the base color (see gtk_widget_modify_base()) for widgets such as #GtkEntry and #GtkTextView. See also gtk_widget_modify_style(). a #GtkWidget. the state for which to set the text color. the color to assign (does not need to be allocated). Sets the #GtkStyle for a widget (@widget->style). You probably don't want to use this function; it interacts badly with themes, because themes work by replacing the #GtkStyle. Instead, use gtk_widget_modify_style(). a #GtkWidget a #GtkStyle. Sets a shape for this widget's GDK window. This allows for transparent windows etc., see gdk_window_shape_combine_mask() for more information. a #GtkWidget. shape to be added. X position of shape mask with respect to @window. Y position of shape mask with respect to @window. The default widget is the widget that's activated when the user presses Enter in a dialog (for example). This function sets the default widget for a #GtkWindow. When setting (rather than unsetting) the default widget it's generally easier to call gtk_widget_grab_focus() on the widget. Before making a widget the default widget, you must set the #GTK_CAN_DEFAULT flag on the widget you'd like to make the default using GTK_WIDGET_SET_FLAGS(). a #GtkWindow widget to be the default. If @focus is not the current focus widget, and is focusable, sets it as the focus widget for the window. To set the focus to a particular widget in the toplevel, it is usually more convenient to use gtk_widget_grab_focus() instead of this function. a #GtkWindow widget to be the new focus widget. Looks for a match between @context->targets and the @dest_target_list, returning the first matching target, otherwise returning %GDK_NONE. @dest_target_list should usually be the return value from gtk_drag_dest_get_target_list(), but some widgets may have different valid targets for different parts of the widget; in that case, they will have to implement a drag_motion handler that passes the correct target list to this function. drag destination widget drag context list of droppable targets. first target that the source offers and the dest can accept, or %GDK_NONE A #GdkImage stores client-side image data (pixels). In contrast, #GdkPixmap and #GdkWindow are server-side objects. gdk_drawable_get_image() obtains the pixels from a server-side drawable as a client-side #GdkImage. The format of a #GdkImage depends on the #GdkVisual of the current display, which makes manipulating #GdkImage extremely difficult; therefore, in most cases you should use the Gdk::Pixbuf constructor that takes a Gdk::Drawable instead of this lower-level function. A #GdkPixbuf contains image data in a canonicalized RGB format, rather than a display-dependent format. Of course, there's a convenience vs. speed tradeoff here, so you'll want to think about what makes sense for your application. @x, @y, @width, and @height define the region of @drawable to obtain as an image. You would usually copy image data to the client side if you intend to examine the values of individual pixels, for example to darken an image or add a red tint. It would be prohibitively slow to make a round-trip request to the windowing system for each pixel, so instead you get all of them at once, modify them, then copy them all back at once. If the X server or other windowing system backend is on the local machine, this function may use shared memory to avoid copying the image data. If the source drawable is a #GdkWindow and partially offscreen or obscured, then the obscured portions of the returned image will contain undefined data. a #GdkDrawable x coordinate on @drawable y coordinate on @drawable width of region to get height or region to get a #GdkImage containing the contents of @drawable Requests the contents of the clipboard as text and converts the result to UTF-8 if necessary. This function waits for the data to be received using the main loop, so events, timeouts, etc, may be dispatched during the wait. a #GtkClipboard A UTF-8 string, which is empty if retrieving the selection data failed. (This could happen for various reasons, in particular if the clipboard was empty or if the contents of the clipboard could not be converted into text form.) Generates a string representation of the path. This string is a ':' separated list of numbers. For example, "4:10:0:3" would be an acceptable return value for this string. A #GtkTreePath The string. Generates a string representation of the iter. This string is a ':' separated list of numbers. For example, "4:10:0:3" would be an acceptable return value for this string. @newin2p2 A #GtkTreeModel. An #GtkTreeIter. The string. Sets the icon for the window. This function is equivalent to calling gtk_window_set_icon() with a pixbuf created by loading the image from @filename. a #GtkWindow location of icon file a #GtkWindow return location for X coordinate of gravity-determined reference point return location for Y coordinate of gravity-determined reference point location of icon file a #GtkWidget the name of a style property location to return the property value a #GtkUIManager object the name of the file to parse a #GtkIconTheme the name of the icon to lookup the desired icon size. The resulting icon may not be exactly this size; see gtk_icon_info_load_icon(). flags modifying the behavior of the icon lookup Gets the name of an icon that is representative of the current theme (for instance, to use when presenting a list of themes to the user.) Since: 2.4 a #GtkIconTheme a #GtkFileChooser filename of the folder to add a #GtkFileChooser filename of the folder to remove a #GtkFileChooser URI of the folder to add a #GtkFileChooser URI of the folder to remove Moves @column to be after to @base_column. See also move_column_to_start(). A #GtkTreeView The #GtkTreeViewColumn to be moved. The #GtkTreeViewColumn to be moved relative to. Obtains the width and height needed to render the cell. Used by view widgets to determine the appropriate size for the cell_area passed to gtk_cell_renderer_render(). Fills in the x and y offsets of the cell relative to this location. Please note that the values set in @width and @height, as well as those in @x_offset and @y_offset are inclusive of the xpad and ypad properties. a #GtkCellRenderer the widget the renderer is rendering to The area a cell will be allocated. location to return x offset of cell relative to @cell_area. location to return y offset of cell relative to @cell_area. location to return width needed to render a cell. location to return height needed to render a cell. Displays a menu and makes it available for selection. Applications can use this function to display context-sensitive menus. The default menu positioning function will position the menu at the current mouse cursor position. The @button parameter should be the mouse button pressed to initiate the menu popup. If the menu popup was initiated by something other than a mouse button press, such as a mouse button release or a keypress, @button should be 0. The @activate_time parameter should be the time stamp of the event that initiated the popup. If such an event is not available, use gtk_get_current_event_time() instead. a #GtkMenu. the menu shell containing the triggering menu item. the menu item whose activation triggered the popup. a user supplied function used to position the menu, or %NULL user supplied data to be passed to @func. the mouse button which was pressed to initiate the event. the time at which the activation event occurred. Obtains the width and height needed to render the column. This is used primarily by the #GtkTreeView. A #GtkTreeViewColumn. The area a cell in the column will be allocated. location to return x offset of a cell relative to @cell_area. location to return y offset of a cell relative to @cell_area. location to return width needed to render a cell. location to return height needed to render a cell. Obtains the horizontal position and size of a cell in a column. If the cell is not found in the column, @start_pos and @width are not changed and %FALSE is returned. a #GtkTreeViewColumn a #GtkCellRenderer return location for the horizontal position of @cell within @tree_column. return location for the width of @cell. %TRUE if @cell belongs to @tree_column. Sets the #GtkAdjustment for the current vertical aspect. See also unset_vadjustment(). A #GtkTreeView The #GtkAdjustment to set. Sets the #GtkAdjustment for the current horizontal aspect. See also unset_hadjustment(). A #GtkTreeView The #GtkAdjustment to set. Sets the column to draw the expander arrow at. It must be in the TreeView. See also reset_expander_column(). A #GtkTreeView The column to draw the expander arrow at. Sets the current keyboard focus to be at @path, and selects it. This is useful when you want to focus the user's attention on a particular row. Focus is given to the column specified. Additionally, if @start_editing is %TRUE, then editing should be started in the specified cell. This function is often followed by Gtk::Widget::grab_focus(@tree_view) in order to give keyboard focus to the widget. Please note that editing can only happen when the widget is realized. A #GtkTreeView A #GtkTreePath A #GtkTreeViewColumn. %TRUE if the specified cell should start being edited. Adds a UI element to the current contents of @self. If @type is %GTK_UI_MANAGER_AUTO, GTK+ inserts a menuitem, toolitem or separator if such an element can be inserted at the place determined by @path. Otherwise @type must indicate an element that can be inserted at the place determined by @path. @see add_ui_separator(). @newin2p4 a #GtkUIManager the merge id for the merged UI, see gtk_ui_manager_new_merge_id() a path the name for the added UI element the name of the action to be proxied, if this is not a separator. the type of UI element to add. if %TRUE, the UI element is added before its siblings, otherwise it is added after its siblings. a #GtkWindow location to store the width of the frame at the left. location to store the height of the frame at the top. location to store the width of the frame at the returns. location to store the height of the frame at the bottom. a #GtkWindow location to store the default width. location to store the default height. a #GtkWindow return location for width. return location for height. a #GtkIconInfo the filename for the icon, or %NULL if gtk_icon_info_get_builtin_pixbuf() should be used instead. a #GtkIconInfo structure the built-in image pixbuf, or %NULL. The returned image must not be modified. a #GtkFileChooser the filename to preview, or an empty string if no file is selected, or if the selected file cannot be represented as a local filename. a #GtkFileChooser the URI for the file to preview, or an empty string if no file is selected. a #GtkFileChooser the URI for the current folder. a #GtkFileChooser The currently selected URI, or an empty string if no file is selected. a #GtkFileChooser The currently selected filename, or an empty string if no file is selected, or the selected file can't be represented with a local filename. A #GtkCellRenderer location to fill in with the fixed width of the widget. location to fill in with the fixed height of the widget. Searches forward for @str. Any match is returned by setting @match_start to the first character of the match and @match_end to the first character after the match. The search will not continue past @limit. Note that a search is a linear or O(n) operation, so you may wish to use @limit to avoid locking up your UI on large buffers. If the #GTK_TEXT_SEARCH_VISIBLE_ONLY flag is present, the match may have invisible text interspersed in @str. i.e. @str will be a possibly-noncontiguous subsequence of the matched range. similarly, if you specify #GTK_TEXT_SEARCH_TEXT_ONLY, the match may have pixbufs or child widgets mixed inside the matched range. If these flags are not given, the match must be exact; the special 0xFFFC character in @str will match embedded pixbufs or child widgets. start of search a search string flags affecting how the search is done return location for start of match return location for end of match bound for the search whether a match was found Same as gtk_text_iter_forward_search(), but moves backward. a #GtkTextIter where the search begins search string bitmask of flags affecting the search return location for start of match return location for end of match location of last possible @match_start whether a match was found Gets the widget that is currenty set as the image of @button. This may have been explicitly set by set_image() or specified as a stock item to the constructor. @newin2p6 a #GtkButton See the Image::Image(const Gtk::StockID& stock_id, IconSize size) constructor for details. a #GtkImage a stock icon name a stock icon size Adds an icon factory to the list of icon factories searched by gtk_style_lookup_icon_set(). This means that, for example, the Image::Image(const Gtk::StockID& stock_id, IconSize size) constructor will be able to find icons in @factory. There will normally be an icon factory added for each library or application that comes with icons. The default icon factories can be overridden by themes. a #GtkIconFactory Sets the name of the stock item. See the ToolButton::ToolButton(const Gtk::StockID& stock_id, IconSize size) constructor. The stock_id property only has an effect if not overridden by "label" and "icon_widget" properties. @newin2p4 a #GtkToolButton a name of a stock item, or %NULL Gets the icon name and size being displayed by the #GtkImage. The storage type of the image must be %GTK_IMAGE_EMPTY or %GTK_IMAGE_ICON_NAME (see gtk_image_get_storage_type()). Since: 2.6 a #GtkImage place to store an icon name place to store an icon size Retrieves the text displayed superimposed on the progress bar, if any. a #GtkProgressBar text. Gets the title of the color selection dialog. Since: 2.4 a #GtkColorButton The title Gets the current folder of @chooser as a local filename. See gtk_file_chooser_set_current_folder(). a #GtkFileChooser the full path of the current folder, possibly empty if the current path cannot be represented as a local filename. This function may also return and empty string if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder() on a nonexistent folder. Since: 2.4 Queries the list of shortcut folders in the file chooser, as set by gtk_file_chooser_add_shortcut_folder(). Since: 2.4 a #GtkFileChooser A list of folder filenames, if there are any shortcut folders.. Queries the list of shortcut folders in the file chooser, as set by gtk_file_chooser_add_shortcut_folder_uri(). a #GtkFileChooser A list of folder URIs Since: 2.4 Lists the current set of user-selectable filters; see gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter(). a #GtkFileChooser a list containing the current set of user selectable filters. Since: 2.4 Lists all the selected files and subfolders in the current folder of @chooser. The returned names are full absolute URIs. a #GtkFileChooser a list containing the URIs of all selected files and subfolders in the current folder. Since: 2.4 Lists all the selected files and subfolders in the current folder of @chooser. The returned names are full absolute paths. If files in the current folder cannot be represented as local filenames they will be ignored. (See gtk_file_chooser_get_uris()) a #GtkFileChooser a list containing the filenames of all selected files and subfolders in the current folder. Since: 2.4 Lists a subset of icons in the current icon theme, by providing a context string. The set of values for the context string is system dependent, but will typically include such values as 'Applications' and 'MimeTypes'. a #GtkIconTheme a string identifying a particular type of icon. The names of all the icons in the theme. Since: 2.4 A convenience function that uses the theme engine and RC file settings for the widget to look up @stock_id and render it to a pixbuf. @stock_id should be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. @size should be a size such as #GTK_ICON_SIZE_MENU. @detail should be a string that identifies the widget or code doing the rendering, so that theme engines can special-case rendering for that widget or code. The pixels in the returned #GdkPixbuf are shared with the rest of the application and should not be modified. The pixbuf should be freed after use with g_object_unref(). a #GtkWidget a stock ID a stock size. A size of (GtkIconSize)-1 means render at the size of the source and don't scale (if there are multiple source sizes, GTK+ picks one of the available sizes). render detail to pass to theme engine a new pixbuf if the stock ID was known. Returns whether the table cells are all constrained to the same width and height. (See set_homogenous()) a #GtkTable %TRUE if the cells are all constrained to the same size Adds a widget to the list of mnemonic labels for this widget. (See gtk_widget_list_mnemonic_labels()). Note the list of mnemonic labels for the widget is cleared when the widget is destroyed, so the caller must make sure to update its internal state at this point as well. Since: 2.4 a #GtkWidget a #GtkWidget that acts as a mnemonic label for @widget. Removes @widget from @container. @widget must be inside @container. If @widget is managed with Gtk::manage(), and you don't want to use @widget again then you should delete @widget, because there will no longer be any parent container to delete it automatically. a #GtkContainer a current child of @container This function adds the page setup from @setup to @key_file. Since: 2.12 a #GtkPageSetup the Glib::KeyFile to save the page setup to the group to add the settings to in @key_file. This function adds the print settings from @settings to @key_file. Since: 2.12 a #GtkPrintSettings the Glib::KeyFile to save the print settings to the group to add the settings to in @key_file. Return value: The program name. a #GtkAboutDialog The program name. Since: 2.12 Return value: The label used for the website link. a #GtkAboutDialog The label used for the website link. Since: 2.6 Get the original text entered by the user that triggered the completion or an empty string if there's no completion ongoing. a #GtkEntryCompletion the prefix for the current completion Since: 2.12 Looks up a named icon and returns a structure containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines these two steps if all you need is the pixbuf.) If @icon_names contains more than one name, this function tries them all in the given order before falling back to inherited icon themes. a #GtkIconTheme array of icon names to lookup desired icon size flags modifying the behavior of the icon lookup a #GtkIconInfo structure containing information about the icon. IconInfo::operator bool() will be false if the icon wasn't found - for instance, if (icon_info) { ... }. Since: 2.12 Gets the list of contexts available within the current hierarchy of icon themes. a #GtkIconTheme a list holding the names of all the contexts in the theme. Since: 2.12 Sets the tip area of @tooltip to the area which @cell occupies in the item pointed to by @path. See also Tooltip::set_tip_area(). Since: 2.12 a #GtkIconView a #GtkTooltip a #GtkTreePath a #GtkCellRenderer. Sets the tip area of @tooltip to be the area covered by the item at @path. See also Tooltip::set_tip_area(). Since: 2.12 a #GtkIconView a #GtkTooltip a #GtkTreePath This function saves the information from @setup to @file_name. @throws Glib::FileError a #GtkPageSetup the file to save to %TRUE on success Since: 2.12 This function saves the print settings from @settings to @file_name. @throws FileError a #GtkPrintSettings the file to save to %TRUE on success Since: 2.12 Requests the printer details. When the details are available, the details_acquired signal will be emitted. Since: 2.12 a #GtkPrinter Return value: a list of cell renderers. a #GtkCellLayout a list of cell renderers. Since: 2.12 Notifies the user about an input-related error on this widget. If the Gtk::Settings gtk-error-bell proeprty is true, it calls Gdk::Window::beep(), otherwise it does nothing. Note that the effect of Gdk::Window::beep() can be configured in many ways, depending on the windowing backend and the desktop environment or window manager that is used. Since: 2.12 a #GtkWidget Gets the contents of the tooltip for @widget. a #GtkWidget the tooltip text. Since: 2.12 Gets the contents of the tooltip for @widget. a #GtkWidget the tooltip text. Since: 2.12 Looks up a named icon and returns a structure containing information such as the filename of the icon. The icon can then be rendered into a pixbuf using gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines these two steps if all you need is the pixbuf.) a #GtkIconTheme the name of the icon to lookup desired icon size flags modifying the behavior of the icon lookup an IconInfo structure containing information about the icon. IconInfo::operator bool() will return false if the icon wasn't found. For instance, if (icon_info) { ... }. Since: 2.4 This function sets the size of stock icons in the toolbar. You can call it both before you add the icons and after they've been added. The size you set will override user preferences for the default icon size. This should only be used for special-purpose toolbars, normal application toolbars should respect the user preferences for the size of icons. Since: 2.12 A #GtkToolbar The #GtkIconSize that stock icons in the toolbar shall have. Unsets toolbar icon size set with gtk_toolbar_set_icon_size(), so that user preferences will be used to determine the icon size. Since: 2.12 a #GtkToolbar