-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Gtk 4.x bindings
--   
--   Bindings for Gtk 4.x, autogenerated by haskell-gi.
@package gi-gtk4
@version 4.0.12


-- | Build time configuration used during code generation.
module GI.Gtk.Config

-- | Overrides used when generating these bindings.
overrides :: Text

-- | Modules in this package
modules :: [Text]


module GI.Gtk.Constants

-- | Disables sorting in a <a>TreeSortable</a>.
--   
--   See also: <a>treeSortableSetSortColumnId</a>

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
pattern TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID :: Int32

-- | Uses the default sort function in a <a>TreeSortable</a>.
--   
--   See also: <a>treeSortableSetSortColumnId</a>

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
pattern TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID :: Int32

-- | The priority at which the text view validates onscreen lines in an
--   idle job in the background.
pattern TEXT_VIEW_PRIORITY_VALIDATE :: Int32

-- | The <tt>GtkSvgFeatures</tt> that are enabled by default.
--   
--   <i>Since: 4.22</i>
pattern SVG_DEFAULT_FEATURES :: Int32

-- | The priority used for the style information from
--   <tt>$XDG_CONFIG_HOME/gtk-4.0/gtk.css</tt>.
--   
--   You should not use priorities higher than this, to give the user the
--   last word.
pattern STYLE_PROVIDER_PRIORITY_USER :: Int32

-- | The priority used for style information provided by themes.
pattern STYLE_PROVIDER_PRIORITY_THEME :: Int32

-- | The priority used for style information provided via
--   <tt>GtkSettings</tt>.
--   
--   This priority is higher than <a>STYLE_PROVIDER_PRIORITY_THEME</a> to
--   let settings override themes.
pattern STYLE_PROVIDER_PRIORITY_SETTINGS :: Int32

-- | The priority used for default style information that is used in the
--   absence of themes.
--   
--   Note that this is not very useful for providing default styling for
--   custom style classes - themes are likely to override styling provided
--   at this priority with catch-all <tt>* {...}</tt> rules.
pattern STYLE_PROVIDER_PRIORITY_FALLBACK :: Int32

-- | A priority that can be used when adding a <tt>GtkStyleProvider</tt>
--   for application-specific style information.
pattern STYLE_PROVIDER_PRIORITY_APPLICATION :: Int32

-- | Use this priority for functionality related to size allocation.
--   
--   It is used internally by GTK+ to compute the sizes of widgets. This
--   priority is higher than <a>PRIORITY_REDRAW</a> to avoid resizing a
--   widget which was just redrawn.
pattern PRIORITY_RESIZE :: Int32

-- | The key used by the “Print to file” printer to store the 32-bit
--   Windows driver version.
pattern PRINT_SETTINGS_WIN32_DRIVER_VERSION :: Text

-- | The key used by the “Print to file” printer to store 32-bit Windows
--   extra driver.
pattern PRINT_SETTINGS_WIN32_DRIVER_EXTRA :: Text

-- | The key used by the “Print to file” printer to store whether to print
--   with colors.
pattern PRINT_SETTINGS_USE_COLOR :: Text

-- | The key used by the “Print to file” printer to store the scale.
pattern PRINT_SETTINGS_SCALE :: Text

-- | The key used by the “Print to file” printer to store whether to
--   reverse the order of the printed pages.
pattern PRINT_SETTINGS_REVERSE :: Text

-- | The key used by the “Print to file” printer to store the vertical
--   resolution in DPI.
pattern PRINT_SETTINGS_RESOLUTION_Y :: Text

-- | The key used by the “Print to file” printer to store the horizontal
--   resolution in DPI.
pattern PRINT_SETTINGS_RESOLUTION_X :: Text

-- | The key used by the “Print to file” printer to store the resolution in
--   DPI.
pattern PRINT_SETTINGS_RESOLUTION :: Text

-- | The key used by the “Print to file” printer to store the printing
--   quality.
pattern PRINT_SETTINGS_QUALITY :: Text

-- | The key used by the “Print to file” printer to store which pages to
--   print.
pattern PRINT_SETTINGS_PRINT_PAGES :: Text

-- | The key used by the “Print to file” printer to store the resolution in
--   lines per inch.
pattern PRINT_SETTINGS_PRINTER_LPI :: Text

-- | The key used by the “Print to file” printer to store the printer name.
pattern PRINT_SETTINGS_PRINTER :: Text

-- | The key used by the “Print to file” printer to store the paper width.
pattern PRINT_SETTINGS_PAPER_WIDTH :: Text

-- | The key used by the “Print to file” printer to store the page height.
pattern PRINT_SETTINGS_PAPER_HEIGHT :: Text

-- | The key used by the “Print to file” printer to store the page format.
pattern PRINT_SETTINGS_PAPER_FORMAT :: Text

-- | The key used by the “Print to file” printer to store the set of pages
--   to print.
pattern PRINT_SETTINGS_PAGE_SET :: Text

-- | The key used by the “Print to file” printer to store the array of page
--   ranges to print.
pattern PRINT_SETTINGS_PAGE_RANGES :: Text

-- | The key used by the “Print to file” printer to store the URI to which
--   the output should be written. GTK itself supports only “file://” URIs.
pattern PRINT_SETTINGS_OUTPUT_URI :: Text

-- | The key used by the “Print to file” printer to store the format of the
--   output. The supported values are “PS” and “PDF”.
pattern PRINT_SETTINGS_OUTPUT_FILE_FORMAT :: Text

-- | The key used by the “Print to file” printer to store the directory to
--   which the output should be written.
pattern PRINT_SETTINGS_OUTPUT_DIR :: Text

-- | The key used by the “Print to file” printer to store the output bin.
pattern PRINT_SETTINGS_OUTPUT_BIN :: Text

-- | The key used by the “Print to file” printer to store the file name of
--   the output without the path to the directory and the file extension.
pattern PRINT_SETTINGS_OUTPUT_BASENAME :: Text

-- | The key used by the “Print to file” printer to store the orientation.
pattern PRINT_SETTINGS_ORIENTATION :: Text

-- | The key used by the “Print to file” printer to store the number of
--   copies.
pattern PRINT_SETTINGS_N_COPIES :: Text

-- | The key used by the “Print to file” printer to store the number of
--   pages per sheet in number-up mode.
pattern PRINT_SETTINGS_NUMBER_UP_LAYOUT :: Text

-- | The key used by the “Print to file” printer to store the number of
--   pages per sheet.
pattern PRINT_SETTINGS_NUMBER_UP :: Text

-- | The key used by the “Print to file” printer to store the media type.
--   
--   The set of media types is defined in PWG 5101.1-2002 PWG.
pattern PRINT_SETTINGS_MEDIA_TYPE :: Text

-- | The key used by the “Print to file” printer to store the finishings.
pattern PRINT_SETTINGS_FINISHINGS :: Text

-- | The key used by the “Print to file” printer to store whether to print
--   the output in duplex.
pattern PRINT_SETTINGS_DUPLEX :: Text

-- | The key used by the “Print to file” printer to store the dither used.
pattern PRINT_SETTINGS_DITHER :: Text

-- | The key used by the “Print to file” printer to store the default
--   source.
pattern PRINT_SETTINGS_DEFAULT_SOURCE :: Text

-- | The key used by the “Print to file” printer to store whether to
--   collate the printed pages.
pattern PRINT_SETTINGS_COLLATE :: Text

-- | Name for the Letter paper size.
pattern PAPER_NAME_LETTER :: Text

-- | Name for the Legal paper size.
pattern PAPER_NAME_LEGAL :: Text

-- | Name for the Executive paper size.
pattern PAPER_NAME_EXECUTIVE :: Text

-- | Name for the B5 paper size.
pattern PAPER_NAME_B5 :: Text

-- | Name for the A5 paper size.
pattern PAPER_NAME_A5 :: Text

-- | Name for the A4 paper size.
pattern PAPER_NAME_A4 :: Text

-- | Name for the A3 paper size.
pattern PAPER_NAME_A3 :: Text

-- | Like [func<i><tt>getMinorVersion</tt></i>], but from the headers used
--   at application compile time, rather than from the library linked
--   against at application run time.
pattern MINOR_VERSION :: Int32

-- | Like [func<i><tt>getMicroVersion</tt></i>], but from the headers used
--   at application compile time, rather than from the library linked
--   against at application run time.
pattern MICRO_VERSION :: Int32

-- | The default extension point name for media file.
pattern MEDIA_FILE_EXTENSION_POINT_NAME :: Text

-- | Evaluates to the maximum length of a compose sequence.
--   
--   This macro is longer used by GTK.
pattern MAX_COMPOSE_LEN :: Int32

-- | Like [func<i><tt>getMajorVersion</tt></i>], but from the headers used
--   at application compile time, rather than from the library linked
--   against at application run time.
pattern MAJOR_VERSION :: Int32

-- | The name used for the stock low offset included by
--   <tt>GtkLevelBar</tt>.
pattern LEVEL_BAR_OFFSET_LOW :: Text

-- | The name used for the stock high offset included by
--   <tt>GtkLevelBar</tt>.
pattern LEVEL_BAR_OFFSET_HIGH :: Text

-- | The name used for the stock full offset included by
--   <tt>GtkLevelBar</tt>.
pattern LEVEL_BAR_OFFSET_FULL :: Text

-- | The value used to refer to a guaranteed invalid position in a
--   <tt>GListModel</tt>.
--   
--   This value may be returned from some functions, others may accept it
--   as input. Its interpretation may differ for different functions.
--   
--   Refer to each function's documentation for if this value is allowed
--   and what it does.
pattern INVALID_LIST_POSITION :: Word32

-- | Like [func<i><tt>getInterfaceAge</tt></i>], but from the headers used
--   at application compile time, rather than from the library linked
--   against at application run time.
pattern INTERFACE_AGE :: Int32

-- | Constant to return from a signal handler for the <a>input</a> signal
--   in case of conversion failure.
--   
--   See <a>SpinButton::input</a>.
pattern INPUT_ERROR :: Int32

-- | The default name of the extension point.
pattern IM_MODULE_EXTENSION_POINT_NAME :: Text

-- | Like [func<i><tt>getBinaryAge</tt></i>], but from the headers used at
--   application compile time, rather than from the library linked against
--   at application run time.
pattern BINARY_AGE :: Int32

-- | An undefined value. The accessible attribute is either unset, or its
--   value is undefined.
pattern ACCESSIBLE_VALUE_UNDEFINED :: Int32

-- | An attribute for the font weight.
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_WEIGHT :: Text

-- | The "unicase" variant value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE :: Text

-- | The "title caps" variant value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS :: Text

-- | The "small caps" variant value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS :: Text

-- | The "petite caps" variant value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS :: Text

-- | The "all small caps" variant value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS :: Text

-- | The "all petite caps" variant value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS :: Text

-- | An attribute for the font variant.
--   
--   Possible values are:
--   
--   <ul>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS]</li>
--   </ul>
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_VARIANT :: Text

-- | The "single" underline value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE :: Text

-- | The "none" underline value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE :: Text

-- | The "error" underline value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR :: Text

-- | The "double" underline value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE :: Text

-- | An attribute for the underline style.
--   
--   Possible values are:
--   
--   <ul>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR]</li>
--   </ul>
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_UNDERLINE :: Text

-- | The "oblique" style value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STYLE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE :: Text

-- | The "normal" style value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STYLE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL :: Text

-- | The "italic" style value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STYLE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC :: Text

-- | An attribute for the font style.
--   
--   Possible values are:
--   
--   <ul>
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL]</li>
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE]</li>
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC]</li>
--   </ul>
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STYLE :: Text

-- | An attribute for strikethrough text.
--   
--   Possible values are <tt>true</tt> or <tt>false</tt>.
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH :: Text

-- | The "ultra expanded" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED :: Text

-- | The "ultra condensed" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED :: Text

-- | The "semi expanded" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED :: Text

-- | The "semi condensed" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED :: Text

-- | The "normal" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL :: Text

-- | The "extra expanded" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED :: Text

-- | The "extra condensed" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED :: Text

-- | The "expanded" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED :: Text

-- | The "condensed" stretch value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED :: Text

-- | An attribute for the font stretch type.
--   
--   Possible values are:
--   
--   <ul>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED]</li>
--   </ul>
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_STRETCH :: Text

-- | An attribute for the font size, expressed in points.
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_SIZE :: Text

-- | The "single" overline value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_OVERLINE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE :: Text

-- | The "none" overline value for
--   [const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_OVERLINE].
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE :: Text

-- | An attribute for the overline style.
--   
--   Possible values are:
--   
--   <ul>
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE]</li>
--   
--   <li>[const<i><tt>gtk</tt></i>.ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE]</li>
--   </ul>
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_OVERLINE :: Text

-- | An attribute for the foreground color, expressed as an RGB value
--   encoded in a string using the format: <tt>{r8},{g8},{b8}</tt>.
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_FOREGROUND :: Text

-- | An attribute for the font family name.
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_FAMILY :: Text

-- | An attribute for the background color, expressed as an RGB value
--   encoded in a string using the format: <tt>{r8},{g8},{b8}</tt>.
--   
--   <i>Since: 4.14</i>
pattern ACCESSIBLE_ATTRIBUTE_BACKGROUND :: Text


module GI.Gtk.Enums

-- | The priority of an accessibility announcement.
--   
--   <i>Since: 4.14</i>
data AccessibleAnnouncementPriority

-- | The announcement is low priority, and might be read only on the user's
--   request.
AccessibleAnnouncementPriorityLow :: AccessibleAnnouncementPriority

-- | The announcement is of medium priority, and is usually spoken at the
--   next opportunity, such as at the end of speaking the current sentence
--   or when the user pauses typing.
AccessibleAnnouncementPriorityMedium :: AccessibleAnnouncementPriority

-- | The announcement is of high priority, and is usually spoken
--   immediately. Because an interruption might disorient users or cause
--   them to not complete their current task, authors SHOULD NOT use high
--   priority announcements unless the interruption is imperative. An
--   example would be a notification about a critical battery power level.
AccessibleAnnouncementPriorityHigh :: AccessibleAnnouncementPriority

-- | Catch-all for unknown values
AnotherAccessibleAnnouncementPriority :: Int -> AccessibleAnnouncementPriority

-- | The possible values for the <a>AccessiblePropertyAutocomplete</a>
--   accessible property.
data AccessibleAutocomplete

-- | Automatic suggestions are not displayed.
AccessibleAutocompleteNone :: AccessibleAutocomplete

-- | When a user is providing input, text suggesting one way to complete
--   the provided input may be dynamically inserted after the caret.
AccessibleAutocompleteInline :: AccessibleAutocomplete

-- | When a user is providing input, an element containing a collection of
--   values that could complete the provided input may be displayed.
AccessibleAutocompleteList :: AccessibleAutocomplete

-- | When a user is providing input, an element containing a collection of
--   values that could complete the provided input may be displayed. If
--   displayed, one value in the collection is automatically selected, and
--   the text needed to complete the automatically selected value appears
--   after the caret in the input.
AccessibleAutocompleteBoth :: AccessibleAutocomplete

-- | Catch-all for unknown values
AnotherAccessibleAutocomplete :: Int -> AccessibleAutocomplete

-- | The possible values for the <a>AccessibleStateInvalid</a> accessible
--   state.
--   
--   Note that the <a>AccessibleInvalidStateFalse</a> and
--   <a>AccessibleInvalidStateTrue</a> have the same values as <a>False</a>
--   and <a>True</a>.
data AccessibleInvalidState

-- | There are no detected errors in the value
AccessibleInvalidStateFalse :: AccessibleInvalidState

-- | The value entered by the user has failed validation
AccessibleInvalidStateTrue :: AccessibleInvalidState

-- | A grammatical error was detected
AccessibleInvalidStateGrammar :: AccessibleInvalidState

-- | A spelling error was detected
AccessibleInvalidStateSpelling :: AccessibleInvalidState

-- | Catch-all for unknown values
AnotherAccessibleInvalidState :: Int -> AccessibleInvalidState

-- | The various platform states which can be queried using
--   <a>accessibleGetPlatformState</a>.
--   
--   <i>Since: 4.10</i>
data AccessiblePlatformState

-- | whether the accessible can be focused
AccessiblePlatformStateFocusable :: AccessiblePlatformState

-- | whether the accessible has focus
AccessiblePlatformStateFocused :: AccessiblePlatformState

-- | whether the accessible is active
AccessiblePlatformStateActive :: AccessiblePlatformState

-- | Catch-all for unknown values
AnotherAccessiblePlatformState :: Int -> AccessiblePlatformState

-- | The possible accessible properties of a
--   [iface<i><tt>accessible</tt></i>].
data AccessibleProperty

-- | Indicates whether inputting text could trigger display of one or more
--   predictions of the user's intended value for a combobox, searchbox, or
--   textbox and specifies how predictions would be presented if they were
--   made. Value type: [enum<i><tt>accessibleAutocomplete</tt></i>]
AccessiblePropertyAutocomplete :: AccessibleProperty

-- | Defines a string value that describes or annotates the current
--   element. Value type: string
AccessiblePropertyDescription :: AccessibleProperty

-- | Indicates the availability of interactive popup element, such as menu
--   or popover, that can be triggered by an element. Contrary to
--   “aria-haspopup”, it doesn't indicate the type of the element, as such
--   it cannot be used to indicate the availability of more complex
--   elements such as dialog. Value type: boolean
AccessiblePropertyHasPopup :: AccessibleProperty

-- | Indicates keyboard shortcuts that an author has implemented to
--   activate or give focus to an element. Value type: string. The format
--   of the value is a space-separated list of shortcuts, with each
--   shortcut consisting of one or more modifiers (<tt>Control</tt>,
--   <tt>Alt</tt> or <tt>Shift</tt>), followed by a non-modifier key, all
--   separated by <tt>+</tt>. The <a>WAI-ARIA</a> reference specifies how
--   to build keyboard shortcuts strings, with specific values for each key
--   which are the same regardless of the language, so these strings can't
--   be built from localized key names. You can convert an accelerator into
--   the matching key shortcuts label with
--   <a>acceleratorGetAccessibleLabel</a>. Examples: <tt>F2</tt>,
--   <tt>Alt+F</tt>, <tt>Control+Shift+N</tt>
AccessiblePropertyKeyShortcuts :: AccessibleProperty

-- | Defines a string value that labels the current element. Value type:
--   string
AccessiblePropertyLabel :: AccessibleProperty

-- | Defines the hierarchical level of an element within a structure. Value
--   type: integer
AccessiblePropertyLevel :: AccessibleProperty

-- | Indicates whether an element is modal when displayed. Value type:
--   boolean
AccessiblePropertyModal :: AccessibleProperty

-- | Indicates whether a text box accepts multiple lines of input or only a
--   single line. Value type: boolean
AccessiblePropertyMultiLine :: AccessibleProperty

-- | Indicates that the user may select more than one item from the current
--   selectable descendants. Value type: boolean
AccessiblePropertyMultiSelectable :: AccessibleProperty

-- | Indicates whether the element's orientation is horizontal, vertical,
--   or unknown/ambiguous. Value type: [enum<i><tt>orientation</tt></i>]
AccessiblePropertyOrientation :: AccessibleProperty

-- | Defines a short hint (a word or short phrase) intended to aid the user
--   with data entry when the control has no value. A hint could be a
--   sample value or a brief description of the expected format. Value
--   type: string
AccessiblePropertyPlaceholder :: AccessibleProperty

-- | Indicates that the element is not editable, but is otherwise operable.
--   Value type: boolean
AccessiblePropertyReadOnly :: AccessibleProperty

-- | Indicates that user input is required on the element before a form may
--   be submitted. Value type: boolean
AccessiblePropertyRequired :: AccessibleProperty

-- | Defines a human-readable, author-localized description for the role of
--   an element. Value type: string
AccessiblePropertyRoleDescription :: AccessibleProperty

-- | Indicates if items in a table or grid are sorted in ascending or
--   descending order. Value type: [enum<i><tt>accessibleSort</tt></i>]
AccessiblePropertySort :: AccessibleProperty

-- | Defines the maximum allowed value for a range widget. Value type:
--   double
AccessiblePropertyValueMax :: AccessibleProperty

-- | Defines the minimum allowed value for a range widget. Value type:
--   double
AccessiblePropertyValueMin :: AccessibleProperty

-- | Defines the current value for a range widget. Value type: double
AccessiblePropertyValueNow :: AccessibleProperty

-- | Defines the human readable text alternative of
--   <a>AccessiblePropertyValueNow</a> for a range widget. Value type:
--   string
AccessiblePropertyValueText :: AccessibleProperty

-- | Defines a string value that provides a description of non-standard
--   keyboard interactions of the current element. Value type: string
--   
--   <i>Since: 4.16</i>
AccessiblePropertyHelpText :: AccessibleProperty

-- | Catch-all for unknown values
AnotherAccessibleProperty :: Int -> AccessibleProperty

-- | The possible accessible relations of a
--   [iface<i><tt>accessible</tt></i>].
--   
--   Accessible relations can be references to other widgets, integers or
--   strings.
data AccessibleRelation

-- | Identifies the currently active element when focus is on a composite
--   widget, combobox, textbox, group, or application. Value type:
--   reference
AccessibleRelationActiveDescendant :: AccessibleRelation

-- | Defines the total number of columns in a table, grid, or treegrid.
--   Value type: integer
AccessibleRelationColCount :: AccessibleRelation

-- | Defines an element's column index or position with respect to the
--   total number of columns within a table, grid, or treegrid. Value type:
--   integer
AccessibleRelationColIndex :: AccessibleRelation

-- | Defines a human readable text alternative of
--   <a>AccessibleRelationColIndex</a>. Value type: string
AccessibleRelationColIndexText :: AccessibleRelation

-- | Defines the number of columns spanned by a cell or gridcell within a
--   table, grid, or treegrid. Value type: integer
AccessibleRelationColSpan :: AccessibleRelation

-- | Identifies the element (or elements) whose contents or presence are
--   controlled by the current element. Value type: reference
AccessibleRelationControls :: AccessibleRelation

-- | Identifies the element (or elements) that describes the object. Value
--   type: reference
AccessibleRelationDescribedBy :: AccessibleRelation

-- | Identifies the element (or elements) that provide additional
--   information related to the object. Value type: reference
AccessibleRelationDetails :: AccessibleRelation

-- | Identifies the element (or elements) that provide an error message for
--   an object. Value type: reference
AccessibleRelationErrorMessage :: AccessibleRelation

-- | Identifies the next element (or elements) in an alternate reading
--   order of content which, at the user's discretion, allows assistive
--   technology to override the general default of reading in document
--   source order. Value type: reference
AccessibleRelationFlowTo :: AccessibleRelation

-- | Identifies the element (or elements) that labels the current element.
--   Value type: reference
AccessibleRelationLabelledBy :: AccessibleRelation

-- | Identifies an element (or elements) in order to define a visual,
--   functional, or contextual parent/child relationship between elements
--   where the widget hierarchy cannot be used to represent the
--   relationship. Value type: reference
AccessibleRelationOwns :: AccessibleRelation

-- | Defines an element's number or position in the current set of
--   listitems or treeitems. Value type: integer
AccessibleRelationPosInSet :: AccessibleRelation

-- | Defines the total number of rows in a table, grid, or treegrid. Value
--   type: integer
AccessibleRelationRowCount :: AccessibleRelation

-- | Defines an element's row index or position with respect to the total
--   number of rows within a table, grid, or treegrid. Value type: integer
AccessibleRelationRowIndex :: AccessibleRelation

-- | Defines a human readable text alternative of
--   <a>AccessibleRelationRowIndex</a>. Value type: string
AccessibleRelationRowIndexText :: AccessibleRelation

-- | Defines the number of rows spanned by a cell or gridcell within a
--   table, grid, or treegrid. Value type: integer
AccessibleRelationRowSpan :: AccessibleRelation

-- | Defines the number of items in the current set of listitems or
--   treeitems. Value type: integer
AccessibleRelationSetSize :: AccessibleRelation

-- | Identifies the element (or elements) that are labeled by the current
--   element. Value type: reference
--   
--   This relation is managed by GTK and should not be set from application
--   code.
--   
--   <i>Since: 4.18</i>
AccessibleRelationLabelFor :: AccessibleRelation

-- | Identifies the element (or elements) that are described by the current
--   element. Value type: reference
--   
--   This relation is managed by GTK and should not be set from application
--   code.
--   
--   <i>Since: 4.18</i>
AccessibleRelationDescriptionFor :: AccessibleRelation

-- | Identifies the element (or elements) that the current element is
--   controlled by. Value type: reference
--   
--   This relation is managed by GTK and should not be set from application
--   code.
--   
--   <i>Since: 4.18</i>
AccessibleRelationControlledBy :: AccessibleRelation

-- | Identifies the element (or elements) for which the current element
--   provides additional information. Value type: reference
--   
--   This relation is managed by GTK and should not be set from application
--   code.
--   
--   <i>Since: 4.18</i>
AccessibleRelationDetailsFor :: AccessibleRelation

-- | Identifies the element (or elements) for which the current element
--   provides an error message. Value type: reference
--   
--   This relation is managed by GTK and should not be set from application
--   code.
--   
--   <i>Since: 4.18</i>
AccessibleRelationErrorMessageFor :: AccessibleRelation

-- | Identifies the previous element (or elements) in an alternate reading
--   order of content which, at the user's discretion, allows assistive
--   technology to override the general default of reading in document
--   source order. Value type: reference
--   
--   This relation is managed by GTK and should not be set from application
--   code.
--   
--   <i>Since: 4.18</i>
AccessibleRelationFlowFrom :: AccessibleRelation

-- | Catch-all for unknown values
AnotherAccessibleRelation :: Int -> AccessibleRelation

-- | The accessible role for a [iface<i><tt>accessible</tt></i>]
--   implementation.
--   
--   Abstract roles are only used as part of the ontology; application
--   developers must not use abstract roles in their code.
data AccessibleRole

-- | An element with important, and usually time-sensitive, information
AccessibleRoleAlert :: AccessibleRole

-- | A type of dialog that contains an alert message
AccessibleRoleAlertDialog :: AccessibleRole

-- | Unused
AccessibleRoleBanner :: AccessibleRole

-- | An input element that allows for user-triggered actions when clicked
--   or pressed
AccessibleRoleButton :: AccessibleRole

-- | Unused
AccessibleRoleCaption :: AccessibleRole

-- | Unused
AccessibleRoleCell :: AccessibleRole

-- | A checkable input element that has three possible values:
--   <tt>true</tt>, <tt>false</tt>, or <tt>mixed</tt>
AccessibleRoleCheckbox :: AccessibleRole

-- | A header in a columned list.
AccessibleRoleColumnHeader :: AccessibleRole

-- | An input that controls another element, such as a list or a grid, that
--   can dynamically pop up to help the user set the value of the input
AccessibleRoleComboBox :: AccessibleRole

-- | Abstract role.
AccessibleRoleCommand :: AccessibleRole

-- | Abstract role.
AccessibleRoleComposite :: AccessibleRole

-- | A dialog is a window that is designed to interrupt the current
--   processing of an application in order to prompt the user to enter
--   information or require a response.
AccessibleRoleDialog :: AccessibleRole

-- | Content that assistive technology users may want to browse in a
--   reading mode.
AccessibleRoleDocument :: AccessibleRole

-- | Unused
AccessibleRoleFeed :: AccessibleRole

-- | Unused
AccessibleRoleForm :: AccessibleRole

-- | A nameless container that has no semantic meaning of its own. This is
--   the role that GTK uses by default for widgets.
AccessibleRoleGeneric :: AccessibleRole

-- | A grid of items.
AccessibleRoleGrid :: AccessibleRole

-- | An item in a grid or tree grid.
AccessibleRoleGridCell :: AccessibleRole

-- | An element that groups multiple related widgets. GTK uses this role
--   for various containers, like <a>HeaderBar</a> or <a>Notebook</a>.
AccessibleRoleGroup :: AccessibleRole

-- | Unused
AccessibleRoleHeading :: AccessibleRole

-- | An image.
AccessibleRoleImg :: AccessibleRole

-- | Abstract role.
AccessibleRoleInput :: AccessibleRole

-- | A visible name or caption for a user interface component.
AccessibleRoleLabel :: AccessibleRole

-- | Abstract role.
AccessibleRoleLandmark :: AccessibleRole

-- | Unused
AccessibleRoleLegend :: AccessibleRole

-- | A clickable link.
AccessibleRoleLink :: AccessibleRole

-- | A list of items.
AccessibleRoleList :: AccessibleRole

-- | Unused.
AccessibleRoleListBox :: AccessibleRole

-- | An item in a list.
AccessibleRoleListItem :: AccessibleRole

-- | Unused
AccessibleRoleLog :: AccessibleRole

-- | Unused
AccessibleRoleMain :: AccessibleRole

-- | Unused
AccessibleRoleMarquee :: AccessibleRole

-- | Unused
AccessibleRoleMath :: AccessibleRole

-- | An element that represents a value within a known range.
AccessibleRoleMeter :: AccessibleRole

-- | A menu.
AccessibleRoleMenu :: AccessibleRole

-- | A menubar.
AccessibleRoleMenuBar :: AccessibleRole

-- | An item in a menu.
AccessibleRoleMenuItem :: AccessibleRole

-- | A check item in a menu.
AccessibleRoleMenuItemCheckbox :: AccessibleRole

-- | A radio item in a menu.
AccessibleRoleMenuItemRadio :: AccessibleRole

-- | Unused
AccessibleRoleNavigation :: AccessibleRole

-- | An element that is not represented to accessibility technologies. This
--   role is synonymous to <i><tt>gTKACCESSIBLEROLEPRESENTATION</tt></i>.
AccessibleRoleNone :: AccessibleRole

-- | Unused
AccessibleRoleNote :: AccessibleRole

-- | Unused
AccessibleRoleOption :: AccessibleRole

-- | An element that is not represented to accessibility technologies. This
--   role is synonymous to <i><tt>gTKACCESSIBLEROLENONE</tt></i>.
AccessibleRolePresentation :: AccessibleRole

-- | An element that displays the progress status for tasks that take a
--   long time.
AccessibleRoleProgressBar :: AccessibleRole

-- | A checkable input in a group of radio roles, only one of which can be
--   checked at a time.
AccessibleRoleRadio :: AccessibleRole

-- | Unused
AccessibleRoleRadioGroup :: AccessibleRole

-- | Abstract role.
AccessibleRoleRange :: AccessibleRole

-- | Unused
AccessibleRoleRegion :: AccessibleRole

-- | A row in a columned list.
AccessibleRoleRow :: AccessibleRole

-- | Unused
AccessibleRoleRowGroup :: AccessibleRole

-- | Unused
AccessibleRoleRowHeader :: AccessibleRole

-- | A graphical object that controls the scrolling of content within a
--   viewing area, regardless of whether the content is fully displayed
--   within the viewing area.
AccessibleRoleScrollbar :: AccessibleRole

-- | Unused
AccessibleRoleSearch :: AccessibleRole

-- | A type of textbox intended for specifying search criteria.
AccessibleRoleSearchBox :: AccessibleRole

-- | Abstract role.
AccessibleRoleSection :: AccessibleRole

-- | Abstract role.
AccessibleRoleSectionHead :: AccessibleRole

-- | Abstract role.
AccessibleRoleSelect :: AccessibleRole

-- | A divider that separates and distinguishes sections of content or
--   groups of menuitems.
AccessibleRoleSeparator :: AccessibleRole

-- | A user input where the user selects a value from within a given range.
AccessibleRoleSlider :: AccessibleRole

-- | A form of range that expects the user to select from among discrete
--   choices.
AccessibleRoleSpinButton :: AccessibleRole

-- | Unused
AccessibleRoleStatus :: AccessibleRole

-- | Abstract role.
AccessibleRoleStructure :: AccessibleRole

-- | A type of checkbox that represents on/off values, as opposed to
--   checked/unchecked values.
AccessibleRoleSwitch :: AccessibleRole

-- | An item in a list of tab used for switching pages.
AccessibleRoleTab :: AccessibleRole

-- | Unused
AccessibleRoleTable :: AccessibleRole

-- | A list of tabs for switching pages.
AccessibleRoleTabList :: AccessibleRole

-- | A page in a notebook or stack.
AccessibleRoleTabPanel :: AccessibleRole

-- | A type of input that allows free-form text as its value.
AccessibleRoleTextBox :: AccessibleRole

-- | Unused
AccessibleRoleTime :: AccessibleRole

-- | Unused
AccessibleRoleTimer :: AccessibleRole

-- | Unused
AccessibleRoleToolbar :: AccessibleRole

-- | Unused
AccessibleRoleTooltip :: AccessibleRole

-- | Unused
AccessibleRoleTree :: AccessibleRole

-- | A treeview-like, columned list.
AccessibleRoleTreeGrid :: AccessibleRole

-- | Unused
AccessibleRoleTreeItem :: AccessibleRole

-- | Abstract role for interactive components of a graphical user interface
AccessibleRoleWidget :: AccessibleRole

-- | Abstract role for windows.
AccessibleRoleWindow :: AccessibleRole

-- | A type of push button which stays pressed until depressed by a second
--   activation.
--   
--   <i>Since: 4.10</i>
AccessibleRoleToggleButton :: AccessibleRole

-- | A toplevel element of a graphical user interface.
--   
--   This is the role that GTK uses by default for windows.
--   
--   <i>Since: 4.12</i>
AccessibleRoleApplication :: AccessibleRole

-- | A paragraph of content.
--   
--   <i>Since: 4.14</i>
AccessibleRoleParagraph :: AccessibleRole

-- | A section of content that is quoted from another source.
--   
--   <i>Since: 4.14</i>
AccessibleRoleBlockQuote :: AccessibleRole

-- | A section of a page that consists of a composition that forms an
--   independent part of a document, page, or site.
--   
--   <i>Since: 4.14</i>
AccessibleRoleArticle :: AccessibleRole

-- | A comment contains content expressing reaction to other content.
--   
--   <i>Since: 4.14</i>
AccessibleRoleComment :: AccessibleRole

-- | A virtual terminal.
--   
--   <i>Since: 4.14</i>
AccessibleRoleTerminal :: AccessibleRole

-- | Catch-all for unknown values
AnotherAccessibleRole :: Int -> AccessibleRole

-- | The possible values for the <a>AccessiblePropertySort</a> accessible
--   property.
data AccessibleSort

-- | There is no defined sort applied to the column.
AccessibleSortNone :: AccessibleSort

-- | Items are sorted in ascending order by this column.
AccessibleSortAscending :: AccessibleSort

-- | Items are sorted in descending order by this column.
AccessibleSortDescending :: AccessibleSort

-- | A sort algorithm other than ascending or descending has been applied.
AccessibleSortOther :: AccessibleSort

-- | Catch-all for unknown values
AnotherAccessibleSort :: Int -> AccessibleSort

-- | The possible accessible states of a [iface<i><tt>accessible</tt></i>].
data AccessibleState

-- | A “busy” state. This state has boolean values
AccessibleStateBusy :: AccessibleState

-- | A “checked” state; indicates the current state of a
--   [class<i><tt>checkButton</tt></i>]. Value type:
--   [enum<i><tt>accessibleTristate</tt></i>]
AccessibleStateChecked :: AccessibleState

-- | A “disabled” state; corresponds to the
--   [property<i><tt>widget</tt></i>:sensitive] property. It indicates a UI
--   element that is perceivable, but not editable or operable. Value type:
--   boolean
AccessibleStateDisabled :: AccessibleState

-- | An “expanded” state; corresponds to the
--   [property<i><tt>expander</tt></i>:expanded] property. Value type:
--   boolean or undefined
AccessibleStateExpanded :: AccessibleState

-- | A “hidden” state; corresponds to the
--   [property<i><tt>widget</tt></i>:visible] property. You can use this
--   state explicitly on UI elements that should not be exposed to an
--   assistive technology. Value type: boolean See also:
--   <a>AccessibleStateDisabled</a>
AccessibleStateHidden :: AccessibleState

-- | An “invalid” state; set when a widget is showing an error. Value type:
--   [enum<i><tt>accessibleInvalidState</tt></i>]
AccessibleStateInvalid :: AccessibleState

-- | A “pressed” state; indicates the current state of a
--   [class<i><tt>toggleButton</tt></i>]. Value type:
--   [enum<i><tt>accessibleTristate</tt></i>] enumeration
AccessibleStatePressed :: AccessibleState

-- | A “selected” state; set when a widget is selected. Value type: boolean
--   or undefined
AccessibleStateSelected :: AccessibleState

-- | Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been
--   visited. Value type: boolean.
--   
--   <i>Since: 4.12</i>
AccessibleStateVisited :: AccessibleState

-- | Catch-all for unknown values
AnotherAccessibleState :: Int -> AccessibleState

-- | The type of contents change operation.
--   
--   <i>Since: 4.14</i>
data AccessibleTextContentChange

-- | contents change as the result of an insert operation
AccessibleTextContentChangeInsert :: AccessibleTextContentChange

-- | contents change as the result of a remove operation
AccessibleTextContentChangeRemove :: AccessibleTextContentChange

-- | Catch-all for unknown values
AnotherAccessibleTextContentChange :: Int -> AccessibleTextContentChange

-- | The granularity for queries about the text contents of a
--   <a>AccessibleText</a> implementation.
--   
--   <i>Since: 4.14</i>
data AccessibleTextGranularity

-- | Use the boundary between characters (including non-printing
--   characters)
AccessibleTextGranularityCharacter :: AccessibleTextGranularity

-- | Use the boundary between words, starting from the beginning of the
--   current word and ending at the beginning of the next word
AccessibleTextGranularityWord :: AccessibleTextGranularity

-- | Use the boundary between sentences, starting from the beginning of the
--   current sentence and ending at the beginning of the next sentence
AccessibleTextGranularitySentence :: AccessibleTextGranularity

-- | Use the boundary between lines, starting from the beginning of the
--   current line and ending at the beginning of the next line
AccessibleTextGranularityLine :: AccessibleTextGranularity

-- | Use the boundary between paragraphs, starting from the beginning of
--   the current paragraph and ending at the beginning of the next
--   paragraph
AccessibleTextGranularityParagraph :: AccessibleTextGranularity

-- | Catch-all for unknown values
AnotherAccessibleTextGranularity :: Int -> AccessibleTextGranularity

-- | The possible values for the <a>AccessibleStatePressed</a> accessible
--   state.
--   
--   Note that the <a>AccessibleTristateFalse</a> and
--   <a>AccessibleTristateTrue</a> have the same values as <a>False</a> and
--   <a>True</a>.
data AccessibleTristate

-- | The state is <tt>false</tt>
AccessibleTristateFalse :: AccessibleTristate

-- | The state is <tt>true</tt>
AccessibleTristateTrue :: AccessibleTristate

-- | The state is <tt>mixed</tt>
AccessibleTristateMixed :: AccessibleTristate

-- | Catch-all for unknown values
AnotherAccessibleTristate :: Int -> AccessibleTristate

-- | Controls how a widget deals with extra space in a single dimension.
--   
--   Alignment only matters if the widget receives a “too large”
--   allocation, for example if you packed the widget with the
--   <a>Widget:hexpand</a> property inside a [class<i><tt>box</tt></i>],
--   then the widget might get extra space. If you have for example a 16x16
--   icon inside a 32x32 space, the icon could be scaled and stretched, it
--   could be centered, or it could be positioned to one side of the space.
--   
--   Note that in horizontal context <tt>GTK_ALIGN_START</tt> and
--   <tt>GTK_ALIGN_END</tt> are interpreted relative to text direction.
--   
--   Baseline support is optional for containers and widgets, and is only
--   available for vertical alignment. <tt>GTK_ALIGN_BASELINE_CENTER</tt>
--   and <tt>GTK_ALIGN_BASELINE_FILL</tt> are treated similar to
--   <tt>GTK_ALIGN_CENTER</tt> and <tt>GTK_ALIGN_FILL</tt>, except that it
--   positions the widget to line up the baselines, where that is
--   supported.
data Align

-- | stretch to fill all space if possible, center if no meaningful way to
--   stretch
AlignFill :: Align

-- | snap to left or top side, leaving space on right or bottom
AlignStart :: Align

-- | snap to right or bottom side, leaving space on left or top
AlignEnd :: Align

-- | center natural width of widget inside the allocation
AlignCenter :: Align

-- | a different name for <tt>GTK_ALIGN_BASELINE</tt>.
--   
--   <i>Since: 4.12</i>
AlignBaselineFill :: Align

-- | align the widget according to the baseline.
AlignBaseline :: Align

-- | stretch to fill all space, but align the baseline.
--   
--   <i>Since: 4.12</i>
AlignBaselineCenter :: Align

-- | Catch-all for unknown values
AnotherAlign :: Int -> Align

-- | Indicates the direction in which an arrow should point.
data ArrowType

-- | Represents an upward pointing arrow.
ArrowTypeUp :: ArrowType

-- | Represents a downward pointing arrow.
ArrowTypeDown :: ArrowType

-- | Represents a left pointing arrow.
ArrowTypeLeft :: ArrowType

-- | Represents a right pointing arrow.
ArrowTypeRight :: ArrowType

-- | No arrow.
ArrowTypeNone :: ArrowType

-- | Catch-all for unknown values
AnotherArrowType :: Int -> ArrowType

-- | Determines the role of a page inside a <tt>GtkAssistant</tt>.
--   
--   The role is used to handle buttons sensitivity and visibility.
--   
--   Note that an assistant needs to end its page flow with a page of type
--   <a>AssistantPageTypeConfirm</a>, <a>AssistantPageTypeSummary</a> or
--   <a>AssistantPageTypeProgress</a> to be correct.
--   
--   The Cancel button will only be shown if the page isn’t “committed”.
--   See <a>assistantCommit</a> for details.

-- | <i>Deprecated: (Since version 4.10)<tt>GtkAssistant</tt> will be
--   removed in GTK 5</i>
data AssistantPageType

-- | The page has regular contents. Both the Back and forward buttons will
--   be shown.
AssistantPageTypeContent :: AssistantPageType

-- | The page contains an introduction to the assistant task. Only the
--   Forward button will be shown if there is a next page.
AssistantPageTypeIntro :: AssistantPageType

-- | The page lets the user confirm or deny the changes. The Back and Apply
--   buttons will be shown.
AssistantPageTypeConfirm :: AssistantPageType

-- | The page informs the user of the changes done. Only the Close button
--   will be shown.
AssistantPageTypeSummary :: AssistantPageType

-- | Used for tasks that take a long time to complete, blocks the assistant
--   until the page is marked as complete. Only the back button will be
--   shown.
AssistantPageTypeProgress :: AssistantPageType

-- | Used for when other page types are not appropriate. No buttons will be
--   shown, and the application must add its own buttons through
--   <a>assistantAddActionWidget</a>.
AssistantPageTypeCustom :: AssistantPageType

-- | Catch-all for unknown values
AnotherAssistantPageType :: Int -> AssistantPageType

-- | Baseline position in a row of widgets.
--   
--   Whenever a container has some form of natural row it may align
--   children in that row along a common typographical baseline. If the
--   amount of vertical space in the row is taller than the total requested
--   height of the baseline-aligned children then it can use a
--   <tt>GtkBaselinePosition</tt> to select where to put the baseline
--   inside the extra available space.
data BaselinePosition

-- | Align the baseline at the top
BaselinePositionTop :: BaselinePosition

-- | Center the baseline
BaselinePositionCenter :: BaselinePosition

-- | Align the baseline at the bottom
BaselinePositionBottom :: BaselinePosition

-- | Catch-all for unknown values
AnotherBaselinePosition :: Int -> BaselinePosition

-- | Describes how the border of a UI element should be rendered.
data BorderStyle

-- | No visible border
BorderStyleNone :: BorderStyle

-- | Same as <a>BorderStyleNone</a>
BorderStyleHidden :: BorderStyle

-- | A single line segment
BorderStyleSolid :: BorderStyle

-- | Looks as if the content is sunken into the canvas
BorderStyleInset :: BorderStyle

-- | Looks as if the content is coming out of the canvas
BorderStyleOutset :: BorderStyle

-- | A series of round dots
BorderStyleDotted :: BorderStyle

-- | A series of square-ended dashes
BorderStyleDashed :: BorderStyle

-- | Two parallel lines with some space between them
BorderStyleDouble :: BorderStyle

-- | Looks as if it were carved in the canvas
BorderStyleGroove :: BorderStyle

-- | Looks as if it were coming out of the canvas
BorderStyleRidge :: BorderStyle

-- | Catch-all for unknown values
AnotherBorderStyle :: Int -> BorderStyle

-- | Error codes that identify various errors that can occur while using
--   <tt>GtkBuilder</tt>.
data BuilderError

-- | A type-func attribute didn’t name a function that returns a
--   <tt>GType</tt>.
BuilderErrorInvalidTypeFunction :: BuilderError

-- | The input contained a tag that <tt>GtkBuilder</tt> can’t handle.
BuilderErrorUnhandledTag :: BuilderError

-- | An attribute that is required by <tt>GtkBuilder</tt> was missing.
BuilderErrorMissingAttribute :: BuilderError

-- | <tt>GtkBuilder</tt> found an attribute that it doesn’t understand.
BuilderErrorInvalidAttribute :: BuilderError

-- | <tt>GtkBuilder</tt> found a tag that it doesn’t understand.
BuilderErrorInvalidTag :: BuilderError

-- | A required property value was missing.
BuilderErrorMissingPropertyValue :: BuilderError

-- | <tt>GtkBuilder</tt> couldn’t parse some attribute value.
BuilderErrorInvalidValue :: BuilderError

-- | The input file requires a newer version of GTK.
BuilderErrorVersionMismatch :: BuilderError

-- | An object id occurred twice.
BuilderErrorDuplicateId :: BuilderError

-- | A specified object type is of the same type or derived from the type
--   of the composite class being extended with builder XML.
BuilderErrorObjectTypeRefused :: BuilderError

-- | The wrong type was specified in a composite class’s template XML
BuilderErrorTemplateMismatch :: BuilderError

-- | The specified property is unknown for the object class.
BuilderErrorInvalidProperty :: BuilderError

-- | The specified signal is unknown for the object class.
BuilderErrorInvalidSignal :: BuilderError

-- | An object id is unknown.
BuilderErrorInvalidId :: BuilderError

-- | A function could not be found. This often happens when symbols are set
--   to be kept private. Compiling code with -rdynamic or using the
--   <tt>gmodule-export-2.0</tt> pkgconfig module can fix this problem.
BuilderErrorInvalidFunction :: BuilderError

-- | Catch-all for unknown values
AnotherBuilderError :: Int -> BuilderError

-- | Catch exceptions of type <a>BuilderError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchBuilderError :: IO a -> (BuilderError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>BuilderError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleBuilderError :: (BuilderError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Prebuilt sets of buttons for <tt>GtkDialog</tt>.
--   
--   If none of these choices are appropriate, simply use
--   <a>ButtonsTypeNone</a> and call
--   <a>Dialog</a>.<tt><i>add_buttons</i></tt>().
--   
--   <pre>
--   Please note that 'GI.Gtk.Enums.ButtonsTypeOk', 'GI.Gtk.Enums.ButtonsTypeYesNo'
--   and 'GI.Gtk.Enums.ButtonsTypeOkCancel' are discouraged by the
--   &lt;https://developer.gnome.org/hig/ GNOME Human Interface Guidelines&gt;.
--   </pre>
data ButtonsType

-- | no buttons at all
ButtonsTypeNone :: ButtonsType

-- | an OK button
ButtonsTypeOk :: ButtonsType

-- | a Close button
ButtonsTypeClose :: ButtonsType

-- | a Cancel button
ButtonsTypeCancel :: ButtonsType

-- | Yes and No buttons
ButtonsTypeYesNo :: ButtonsType

-- | OK and Cancel buttons
ButtonsTypeOkCancel :: ButtonsType

-- | Catch-all for unknown values
AnotherButtonsType :: Int -> ButtonsType

-- | The available modes for <a>CellRendererAccel:accelMode</a>.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
data CellRendererAccelMode

-- | GTK accelerators mode
CellRendererAccelModeGtk :: CellRendererAccelMode

-- | Other accelerator mode
CellRendererAccelModeOther :: CellRendererAccelMode

-- | Catch-all for unknown values
AnotherCellRendererAccelMode :: Int -> CellRendererAccelMode

-- | Identifies how the user can interact with a particular cell.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data CellRendererMode

-- | The cell is just for display and cannot be interacted with. Note that
--   this doesn’t mean that eg. the row being drawn can’t be selected --
--   just that a particular element of it cannot be individually modified.
CellRendererModeInert :: CellRendererMode

-- | The cell can be clicked.
CellRendererModeActivatable :: CellRendererMode

-- | The cell can be edited or otherwise modified.
CellRendererModeEditable :: CellRendererMode

-- | Catch-all for unknown values
AnotherCellRendererMode :: Int -> CellRendererMode

-- | Describes how a <a>StringSorter</a> turns strings into sort keys to
--   compare them.
--   
--   Note that the result of sorting will in general depend on the current
--   locale unless the mode is <i><tt>gTKCOLLATIONNONE</tt></i>.
--   
--   <i>Since: 4.10</i>
data Collation

-- | Don't do any collation
CollationNone :: Collation

-- | Use <a>utf8CollateKey</a>
CollationUnicode :: Collation

-- | Use <a>utf8CollateKeyForFilename</a>
CollationFilename :: Collation

-- | Catch-all for unknown values
AnotherCollation :: Int -> Collation

-- | The widget attributes that can be used when creating a
--   [class<i><tt>constraint</tt></i>].
data ConstraintAttribute

-- | No attribute, used for constant relations
ConstraintAttributeNone :: ConstraintAttribute

-- | The left edge of a widget, regardless of text direction
ConstraintAttributeLeft :: ConstraintAttribute

-- | The right edge of a widget, regardless of text direction
ConstraintAttributeRight :: ConstraintAttribute

-- | The top edge of a widget
ConstraintAttributeTop :: ConstraintAttribute

-- | The bottom edge of a widget
ConstraintAttributeBottom :: ConstraintAttribute

-- | The leading edge of a widget, depending on text direction; equivalent
--   to <a>ConstraintAttributeLeft</a> for LTR languages, and
--   <a>ConstraintAttributeRight</a> for RTL ones
ConstraintAttributeStart :: ConstraintAttribute

-- | The trailing edge of a widget, depending on text direction; equivalent
--   to <a>ConstraintAttributeRight</a> for LTR languages, and
--   <a>ConstraintAttributeLeft</a> for RTL ones
ConstraintAttributeEnd :: ConstraintAttribute

-- | The width of a widget
ConstraintAttributeWidth :: ConstraintAttribute

-- | The height of a widget
ConstraintAttributeHeight :: ConstraintAttribute

-- | The center of a widget, on the horizontal axis
ConstraintAttributeCenterX :: ConstraintAttribute

-- | The center of a widget, on the vertical axis
ConstraintAttributeCenterY :: ConstraintAttribute

-- | The baseline of a widget
ConstraintAttributeBaseline :: ConstraintAttribute

-- | Catch-all for unknown values
AnotherConstraintAttribute :: Int -> ConstraintAttribute

-- | The relation between two terms of a constraint.
data ConstraintRelation

-- | Less than, or equal
ConstraintRelationLe :: ConstraintRelation

-- | Equal
ConstraintRelationEq :: ConstraintRelation

-- | Greater than, or equal
ConstraintRelationGe :: ConstraintRelation

-- | Catch-all for unknown values
AnotherConstraintRelation :: Int -> ConstraintRelation

-- | The strength of a constraint, expressed as a symbolic constant.
--   
--   The strength of a [class<i><tt>constraint</tt></i>] can be expressed
--   with any positive integer; the values of this enumeration can be used
--   for readability.
data ConstraintStrength

-- | The constraint is required towards solving the layout
ConstraintStrengthRequired :: ConstraintStrength

-- | A strong constraint
ConstraintStrengthStrong :: ConstraintStrength

-- | A medium constraint
ConstraintStrengthMedium :: ConstraintStrength

-- | A weak constraint
ConstraintStrengthWeak :: ConstraintStrength

-- | Catch-all for unknown values
AnotherConstraintStrength :: Int -> ConstraintStrength

-- | Domain for VFL parsing errors.
data ConstraintVflParserError

-- | Invalid or unknown symbol
ConstraintVflParserErrorInvalidSymbol :: ConstraintVflParserError

-- | Invalid or unknown attribute
ConstraintVflParserErrorInvalidAttribute :: ConstraintVflParserError

-- | Invalid or unknown view
ConstraintVflParserErrorInvalidView :: ConstraintVflParserError

-- | Invalid or unknown metric
ConstraintVflParserErrorInvalidMetric :: ConstraintVflParserError

-- | Invalid or unknown priority
ConstraintVflParserErrorInvalidPriority :: ConstraintVflParserError

-- | Invalid or unknown relation
ConstraintVflParserErrorInvalidRelation :: ConstraintVflParserError

-- | Catch-all for unknown values
AnotherConstraintVflParserError :: Int -> ConstraintVflParserError

-- | Catch exceptions of type <a>ConstraintVflParserError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchConstraintVflParserError :: IO a -> (ConstraintVflParserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>ConstraintVflParserError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleConstraintVflParserError :: (ConstraintVflParserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Controls how a content should be made to fit inside an allocation.
--   
--   <i>Since: 4.8</i>
data ContentFit

-- | Make the content fill the entire allocation, without taking its aspect
--   ratio in consideration. The resulting content will appear as stretched
--   if its aspect ratio is different from the allocation aspect ratio.
ContentFitFill :: ContentFit

-- | Scale the content to fit the allocation, while taking its aspect ratio
--   in consideration. The resulting content will appear as letterboxed if
--   its aspect ratio is different from the allocation aspect ratio.
ContentFitContain :: ContentFit

-- | Cover the entire allocation, while taking the content aspect ratio in
--   consideration. The resulting content will appear as clipped if its
--   aspect ratio is different from the allocation aspect ratio.
ContentFitCover :: ContentFit

-- | The content is scaled down to fit the allocation, if needed, otherwise
--   its original size is used.
ContentFitScaleDown :: ContentFit

-- | Catch-all for unknown values
AnotherContentFit :: Int -> ContentFit

-- | Specifies which corner a child widget should be placed in when packed
--   into a <tt>GtkScrolledWindow.</tt>
--   
--   This is effectively the opposite of where the scroll bars are placed.
data CornerType

-- | Place the scrollbars on the right and bottom of the widget (default
--   behaviour).
CornerTypeTopLeft :: CornerType

-- | Place the scrollbars on the top and right of the widget.
CornerTypeBottomLeft :: CornerType

-- | Place the scrollbars on the left and bottom of the widget.
CornerTypeTopRight :: CornerType

-- | Place the scrollbars on the top and left of the widget.
CornerTypeBottomRight :: CornerType

-- | Catch-all for unknown values
AnotherCornerType :: Int -> CornerType

-- | Errors that can occur while parsing CSS.
--   
--   These errors are unexpected and will cause parts of the given CSS to
--   be ignored.
data CssParserError

-- | Unknown failure.
CssParserErrorFailed :: CssParserError

-- | The given text does not form valid syntax
CssParserErrorSyntax :: CssParserError

-- | Failed to import a resource
CssParserErrorImport :: CssParserError

-- | The given name has not been defined
CssParserErrorName :: CssParserError

-- | The given value is not correct
CssParserErrorUnknownValue :: CssParserError

-- | Catch-all for unknown values
AnotherCssParserError :: Int -> CssParserError

-- | Catch exceptions of type <a>CssParserError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchCssParserError :: IO a -> (CssParserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>CssParserError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleCssParserError :: (CssParserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Warnings that can occur while parsing CSS.
--   
--   Unlike <tt>GtkCssParserError</tt>s, warnings do not cause the parser
--   to skip any input, but they indicate issues that should be fixed.
data CssParserWarning

-- | The given construct is deprecated and will be removed in a future
--   version
CssParserWarningDeprecated :: CssParserWarning

-- | A syntax construct was used that should be avoided
CssParserWarningSyntax :: CssParserWarning

-- | A feature is not implemented
CssParserWarningUnimplemented :: CssParserWarning

-- | Catch-all for unknown values
AnotherCssParserWarning :: Int -> CssParserWarning

-- | Passed to various keybinding signals for deleting text.
data DeleteType

-- | Delete characters.
DeleteTypeChars :: DeleteType

-- | Delete only the portion of the word to the left/right of cursor if
--   we’re in the middle of a word.
DeleteTypeWordEnds :: DeleteType

-- | Delete words.
DeleteTypeWords :: DeleteType

-- | Delete display-lines. Display-lines refers to the visible lines, with
--   respect to the current line breaks. As opposed to paragraphs, which
--   are defined by line breaks in the input.
DeleteTypeDisplayLines :: DeleteType

-- | Delete only the portion of the display-line to the left/right of
--   cursor.
DeleteTypeDisplayLineEnds :: DeleteType

-- | Delete to the end of the paragraph. Like C-k in Emacs (or its
--   reverse).
DeleteTypeParagraphEnds :: DeleteType

-- | Delete entire line. Like C-k in pico.
DeleteTypeParagraphs :: DeleteType

-- | Delete only whitespace. Like M-\ in Emacs.
DeleteTypeWhitespace :: DeleteType

-- | Catch-all for unknown values
AnotherDeleteType :: Int -> DeleteType

-- | Error codes in the <tt>GTK_DIALOG_ERROR</tt> domain that can be
--   returned by async dialog functions.
--   
--   <i>Since: 4.10</i>
data DialogError

-- | Generic error condition for when an operation fails and no more
--   specific code is applicable
DialogErrorFailed :: DialogError

-- | The async function call was cancelled via its <tt>GCancellable</tt>
DialogErrorCancelled :: DialogError

-- | The operation was cancelled by the user (via a Cancel or Close button)
DialogErrorDismissed :: DialogError

-- | Catch-all for unknown values
AnotherDialogError :: Int -> DialogError

-- | Catch exceptions of type <a>DialogError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchDialogError :: IO a -> (DialogError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>DialogError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleDialogError :: (DialogError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Focus movement types.
data DirectionType

-- | Move forward.
DirectionTypeTabForward :: DirectionType

-- | Move backward.
DirectionTypeTabBackward :: DirectionType

-- | Move up.
DirectionTypeUp :: DirectionType

-- | Move down.
DirectionTypeDown :: DirectionType

-- | Move left.
DirectionTypeLeft :: DirectionType

-- | Move right.
DirectionTypeRight :: DirectionType

-- | Catch-all for unknown values
AnotherDirectionType :: Int -> DirectionType

-- | The identifiers for <a>Editable</a> properties.
--   
--   See <a>editableInstallProperties</a> for details on how to implement
--   the <tt>GtkEditable</tt> interface.
data EditableProperties

-- | the property id for <a>Editable:text</a>
EditablePropertiesPropText :: EditableProperties

-- | the property id for <a>Editable:cursorPosition</a>
EditablePropertiesPropCursorPosition :: EditableProperties

-- | the property id for <a>Editable:selectionBound</a>
EditablePropertiesPropSelectionBound :: EditableProperties

-- | the property id for <a>Editable:editable</a>
EditablePropertiesPropEditable :: EditableProperties

-- | the property id for <a>Editable:widthChars</a>
EditablePropertiesPropWidthChars :: EditableProperties

-- | the property id for <a>Editable:maxWidthChars</a>
EditablePropertiesPropMaxWidthChars :: EditableProperties

-- | the property id for <a>Editable:xalign</a>
EditablePropertiesPropXalign :: EditableProperties

-- | the property id for <a>Editable:enableUndo</a>
EditablePropertiesPropEnableUndo :: EditableProperties

-- | the number of properties
EditablePropertiesNumProperties :: EditableProperties

-- | Catch-all for unknown values
AnotherEditableProperties :: Int -> EditableProperties

-- | Specifies the side of the entry at which an icon is placed.
data EntryIconPosition

-- | At the beginning of the entry (depending on the text direction).
EntryIconPositionPrimary :: EntryIconPosition

-- | At the end of the entry (depending on the text direction).
EntryIconPositionSecondary :: EntryIconPosition

-- | Catch-all for unknown values
AnotherEntryIconPosition :: Int -> EntryIconPosition

-- | Describes the state of a <a>EventSequence</a> in a
--   [class<i><tt>gesture</tt></i>].
data EventSequenceState

-- | The sequence is handled, but not grabbed.
EventSequenceStateNone :: EventSequenceState

-- | The sequence is handled and grabbed.
EventSequenceStateClaimed :: EventSequenceState

-- | The sequence is denied.
EventSequenceStateDenied :: EventSequenceState

-- | Catch-all for unknown values
AnotherEventSequenceState :: Int -> EventSequenceState

-- | Describes whether a <tt>GtkFileChooser</tt> is being used to open
--   existing files or to save to a possibly new file.
data FileChooserAction

-- | Indicates open mode. The file chooser will only let the user pick an
--   existing file.
FileChooserActionOpen :: FileChooserAction

-- | Indicates save mode. The file chooser will let the user pick an
--   existing file, or type in a new filename.
FileChooserActionSave :: FileChooserAction

-- | Indicates an Open mode for selecting folders. The file chooser will
--   let the user pick an existing folder.
FileChooserActionSelectFolder :: FileChooserAction

-- | Catch-all for unknown values
AnotherFileChooserAction :: Int -> FileChooserAction

-- | These identify the various errors that can occur while calling
--   <tt>GtkFileChooser</tt> functions.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
data FileChooserError

-- | Indicates that a file does not exist.
FileChooserErrorNonexistent :: FileChooserError

-- | Indicates a malformed filename.
FileChooserErrorBadFilename :: FileChooserError

-- | Indicates a duplicate path (e.g. when adding a bookmark).
FileChooserErrorAlreadyExists :: FileChooserError

-- | Indicates an incomplete hostname (e.g. "http://foo" without a slash
--   after that).
FileChooserErrorIncompleteHostname :: FileChooserError

-- | Catch-all for unknown values
AnotherFileChooserError :: Int -> FileChooserError

-- | Catch exceptions of type <a>FileChooserError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchFileChooserError :: IO a -> (FileChooserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>FileChooserError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleFileChooserError :: (FileChooserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Describes changes in a filter in more detail and allows objects using
--   the filter to optimize refiltering items.
--   
--   If you are writing an implementation and are not sure which value to
--   pass, <tt>GTK_FILTER_CHANGE_DIFFERENT</tt> is always a correct choice.
--   
--   New values may be added in the future.
data FilterChange

-- | The filter change cannot be described with any of the other
--   enumeration values
FilterChangeDifferent :: FilterChange

-- | The filter is less strict than it was before: All items that it used
--   to return true still return true, others now may, too.
FilterChangeLessStrict :: FilterChange

-- | The filter is more strict than it was before: All items that it used
--   to return false still return false, others now may, too.
FilterChangeMoreStrict :: FilterChange

-- | Similar to <a>FilterChangeDifferent</a>, but signs that item watches
--   should be recreated. This is used by <a>FilterListModel</a> to keep
--   the list up-to-date when items change.
--   
--   <i>Since: 4.20</i>
FilterChangeDifferentRewatch :: FilterChange

-- | Similar to <a>FilterChangeLessStrict</a>, but signs that item watches
--   should be recreated. This is used by <a>FilterListModel</a> to keep
--   the list up-to-date when items change.
--   
--   <i>Since: 4.20</i>
FilterChangeLessStrictRewatch :: FilterChange

-- | Similar to <a>FilterChangeMoreStrict</a>, but signs that item watches
--   should be recreated. This is used by <a>FilterListModel</a> to keep
--   the list up-to-date when items change.
--   
--   <i>Since: 4.20</i>
FilterChangeMoreStrictRewatch :: FilterChange

-- | Catch-all for unknown values
AnotherFilterChange :: Int -> FilterChange

-- | Describes the known strictness of a filter.
--   
--   Note that for filters where the strictness is not known,
--   <tt>GTK_FILTER_MATCH_SOME</tt> is always an acceptable value, even if
--   a filter does match all or no items.
data FilterMatch

-- | The filter matches some items, <a>filterMatch</a> may return true or
--   false
FilterMatchSome :: FilterMatch

-- | The filter does not match any item, <a>filterMatch</a> will always
--   return false
FilterMatchNone :: FilterMatch

-- | The filter matches all items, <a>filterMatch</a> will alays return
--   true
FilterMatchAll :: FilterMatch

-- | Catch-all for unknown values
AnotherFilterMatch :: Int -> FilterMatch

-- | The level of granularity for the font selection.
--   
--   Depending on this value, the <tt>PangoFontDescription</tt> that is
--   returned by <a>fontDialogButtonGetFontDesc</a> will have more or less
--   fields set.
--   
--   <i>Since: 4.10</i>
data FontLevel

-- | Select a font family
FontLevelFamily :: FontLevel

-- | Select a font face (i.e. a family and a style)
FontLevelFace :: FontLevel

-- | Select a font (i.e. a face with a size, and possibly font variations)
FontLevelFont :: FontLevel

-- | Select a font and font features
FontLevelFeatures :: FontLevel

-- | Catch-all for unknown values
AnotherFontLevel :: Int -> FontLevel

-- | Values for the <a>Settings:gtkFontRendering</a> setting that influence
--   how GTK renders fonts.
--   
--   <i>Since: 4.16</i>
data FontRendering

-- | Set up font rendering automatically, taking factors like screen
--   resolution and scale into account
FontRenderingAutomatic :: FontRendering

-- | Follow low-level font-related settings when configuring font rendering
FontRenderingManual :: FontRendering

-- | Catch-all for unknown values
AnotherFontRendering :: Int -> FontRendering

-- | Represents the state of graphics offloading.
--   
--   <i>Since: 4.14</i>
data GraphicsOffloadEnabled

-- | Graphics offloading is enabled.
GraphicsOffloadEnabledEnabled :: GraphicsOffloadEnabled

-- | Graphics offloading is disabled.
GraphicsOffloadEnabledDisabled :: GraphicsOffloadEnabled

-- | Catch-all for unknown values
AnotherGraphicsOffloadEnabled :: Int -> GraphicsOffloadEnabled

-- | Built-in icon sizes.
--   
--   Icon sizes default to being inherited. Where they cannot be inherited,
--   text size is the default.
--   
--   All widgets which use <tt>GtkIconSize</tt> set the normal-icons or
--   large-icons style classes correspondingly, and let themes determine
--   the actual size to be used with the <tt>-gtk-icon-size</tt> CSS
--   property.
data IconSize

-- | Keep the size of the parent element
IconSizeInherit :: IconSize

-- | Size similar to text size
IconSizeNormal :: IconSize

-- | Large size, for example in an icon view
IconSizeLarge :: IconSize

-- | Catch-all for unknown values
AnotherIconSize :: Int -> IconSize

-- | Error codes for <tt>GtkIconTheme</tt> operations.
data IconThemeError

-- | The icon specified does not exist in the theme
IconThemeErrorNotFound :: IconThemeError

-- | An unspecified error occurred.
IconThemeErrorFailed :: IconThemeError

-- | Catch-all for unknown values
AnotherIconThemeError :: Int -> IconThemeError

-- | Catch exceptions of type <a>IconThemeError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchIconThemeError :: IO a -> (IconThemeError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>IconThemeError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleIconThemeError :: (IconThemeError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | An enum for determining where a dropped item goes.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data IconViewDropPosition

-- | no drop possible
IconViewDropPositionNoDrop :: IconViewDropPosition

-- | dropped item replaces the item
IconViewDropPositionDropInto :: IconViewDropPosition

-- | dropped item is inserted to the left
IconViewDropPositionDropLeft :: IconViewDropPosition

-- | dropped item is inserted to the right
IconViewDropPositionDropRight :: IconViewDropPosition

-- | dropped item is inserted above
IconViewDropPositionDropAbove :: IconViewDropPosition

-- | dropped item is inserted below
IconViewDropPositionDropBelow :: IconViewDropPosition

-- | Catch-all for unknown values
AnotherIconViewDropPosition :: Int -> IconViewDropPosition

-- | Describes the image data representation used by a <a>Image</a>.
--   
--   If you want to get the image from the widget, you can only get the
--   currently-stored representation; for instance, if the
--   <a>imageGetStorageType</a> returns <a>ImageTypePaintable</a>, then you
--   can call <a>imageGetPaintable</a>.
--   
--   For empty images, you can request any storage type (call any of the
--   "get" functions), but they will all return <a>Nothing</a> values.
data ImageType

-- | there is no image displayed by the widget
ImageTypeEmpty :: ImageType

-- | the widget contains a named icon
ImageTypeIconName :: ImageType

-- | the widget contains a <tt>GIcon</tt>
ImageTypeGicon :: ImageType

-- | the widget contains a <tt>GdkPaintable</tt>
ImageTypePaintable :: ImageType

-- | Catch-all for unknown values
AnotherImageType :: Int -> ImageType

-- | Describes primary purpose of the input widget.
--   
--   This information is useful for on-screen keyboards and similar input
--   methods to decide which keys should be presented to the user.
--   
--   Note that the purpose is not meant to impose a totally strict rule
--   about allowed characters, and does not replace input validation. It is
--   fine for an on-screen keyboard to let the user override the character
--   set restriction that is expressed by the purpose. The application is
--   expected to validate the entry contents, even if it specified a
--   purpose.
--   
--   The difference between <a>InputPurposeDigits</a> and
--   <a>InputPurposeNumber</a> is that the former accepts only digits while
--   the latter also some punctuation (like commas or points, plus, minus)
--   and “e” or “E” as in 3.14E+000.
--   
--   This enumeration may be extended in the future; input methods should
--   interpret unknown values as “free form”.
data InputPurpose

-- | Allow any character
InputPurposeFreeForm :: InputPurpose

-- | Allow only alphabetic characters
InputPurposeAlpha :: InputPurpose

-- | Allow only digits
InputPurposeDigits :: InputPurpose

-- | Edited field expects numbers
InputPurposeNumber :: InputPurpose

-- | Edited field expects phone number
InputPurposePhone :: InputPurpose

-- | Edited field expects URL
InputPurposeUrl :: InputPurpose

-- | Edited field expects email address
InputPurposeEmail :: InputPurpose

-- | Edited field expects the name of a person
InputPurposeName :: InputPurpose

-- | Like <a>InputPurposeFreeForm</a>, but characters are hidden
InputPurposePassword :: InputPurpose

-- | Like <a>InputPurposeDigits</a>, but characters are hidden
InputPurposePin :: InputPurpose

-- | Allow any character, in addition to control codes
InputPurposeTerminal :: InputPurpose

-- | Catch-all for unknown values
AnotherInputPurpose :: Int -> InputPurpose

-- | The different methods to handle text in <a>Inscription</a> when it
--   doesn't fit the available space.
--   
--   <i>Since: 4.8</i>
data InscriptionOverflow

-- | Clip the remaining text
InscriptionOverflowClip :: InscriptionOverflow

-- | Omit characters at the start of the text
InscriptionOverflowEllipsizeStart :: InscriptionOverflow

-- | Omit characters at the middle of the text
InscriptionOverflowEllipsizeMiddle :: InscriptionOverflow

-- | Omit characters at the end of the text
InscriptionOverflowEllipsizeEnd :: InscriptionOverflow

-- | Catch-all for unknown values
AnotherInscriptionOverflow :: Int -> InscriptionOverflow

-- | Values for the <a>Settings:gtkInterfaceColorScheme</a> and
--   <a>CssProvider:prefersColorScheme</a> properties that indicates what
--   color scheme is used.
--   
--   This information can be used inside CSS via media queries.
--   
--   More values may be added to this enumeration. Unknown values should be
--   treated the same as <tt>GTK_INTERFACE_COLOR_SCHEME_DEFAULT</tt>.
--   
--   <i>Since: 4.20</i>
data InterfaceColorScheme

-- | The system doesn't support color schemes
InterfaceColorSchemeUnsupported :: InterfaceColorScheme

-- | The default color scheme is used
InterfaceColorSchemeDefault :: InterfaceColorScheme

-- | A dark color scheme is used
InterfaceColorSchemeDark :: InterfaceColorScheme

-- | A light color scheme is used
InterfaceColorSchemeLight :: InterfaceColorScheme

-- | Catch-all for unknown values
AnotherInterfaceColorScheme :: Int -> InterfaceColorScheme

-- | Values for the <a>Settings:gtkInterfaceContrast</a> and
--   <a>CssProvider:prefersContrast</a> properties that indicates the
--   preferred level of contrast.
--   
--   This information can be used inside CSS via media queries.
--   
--   More values may be added to this enumeration. Unknown values should be
--   treated the same as <tt>GTK_INTERFACE_CONTRAST_NO_PREFERENCE</tt>.
--   
--   <i>Since: 4.20</i>
data InterfaceContrast

-- | The system doesn't support contrast levels
InterfaceContrastUnsupported :: InterfaceContrast

-- | No particular preference for contrast
InterfaceContrastNoPreference :: InterfaceContrast

-- | More contrast is preferred
InterfaceContrastMore :: InterfaceContrast

-- | Less contrast is preferred
InterfaceContrastLess :: InterfaceContrast

-- | Catch-all for unknown values
AnotherInterfaceContrast :: Int -> InterfaceContrast

-- | Used for justifying the text inside a [class<i><tt>label</tt></i>]
--   widget.
data Justification

-- | The text is placed at the left edge of the label.
JustificationLeft :: Justification

-- | The text is placed at the right edge of the label.
JustificationRight :: Justification

-- | The text is placed in the center of the label.
JustificationCenter :: Justification

-- | The text is placed is distributed across the label.
JustificationFill :: Justification

-- | Catch-all for unknown values
AnotherJustification :: Int -> Justification

-- | Describes how [class<i><tt>levelBar</tt></i>] contents should be
--   rendered.
--   
--   Note that this enumeration could be extended with additional modes in
--   the future.
data LevelBarMode

-- | the bar has a continuous mode
LevelBarModeContinuous :: LevelBarMode

-- | the bar has a discrete mode
LevelBarModeDiscrete :: LevelBarMode

-- | Catch-all for unknown values
AnotherLevelBarMode :: Int -> LevelBarMode

-- | The type of license for an application.
--   
--   This enumeration can be expanded at later date.
data License

-- | No license specified
LicenseUnknown :: License

-- | A license text is going to be specified by the developer
LicenseCustom :: License

-- | The GNU General Public License, version 2.0 or later
LicenseGpl20 :: License

-- | The GNU General Public License, version 3.0 or later
LicenseGpl30 :: License

-- | The GNU Lesser General Public License, version 2.1 or later
LicenseLgpl21 :: License

-- | The GNU Lesser General Public License, version 3.0 or later
LicenseLgpl30 :: License

-- | The BSD standard license
LicenseBsd :: License

-- | The MIT/X11 standard license
LicenseMitX11 :: License

-- | The Artistic License, version 2.0
LicenseArtistic :: License

-- | The GNU General Public License, version 2.0 only
LicenseGpl20Only :: License

-- | The GNU General Public License, version 3.0 only
LicenseGpl30Only :: License

-- | The GNU Lesser General Public License, version 2.1 only
LicenseLgpl21Only :: License

-- | The GNU Lesser General Public License, version 3.0 only
LicenseLgpl30Only :: License

-- | The GNU Affero General Public License, version 3.0 or later
LicenseAgpl30 :: License

-- | The GNU Affero General Public License, version 3.0 only
LicenseAgpl30Only :: License

-- | The 3-clause BSD licence
LicenseBsd3 :: License

-- | The Apache License, version 2.0
LicenseApache20 :: License

-- | The Mozilla Public License, version 2.0
LicenseMpl20 :: License

-- | Zero-Clause BSD license
License0bsd :: License

-- | Catch-all for unknown values
AnotherLicense :: Int -> License

-- | Used to configure the focus behavior in the
--   <tt>GTK_DIR_TAB_FORWARD</tt> and <tt>GTK_DIR_TAB_BACKWARD</tt>
--   direction, like the &lt;kbd&gt;Tab&lt;/kbd&gt; key in a
--   <a>ListView</a>.
--   
--   <i>Since: 4.12</i>
data ListTabBehavior

-- | Cycle through all focusable items of the list
ListTabBehaviorAll :: ListTabBehavior

-- | Cycle through a single list element, then move focus out of the list.
--   Moving focus between items needs to be done with the arrow keys.
ListTabBehaviorItem :: ListTabBehavior

-- | Cycle only through a single cell, then move focus out of the list.
--   Moving focus between cells needs to be done with the arrow keys. This
--   is only relevant for cell-based widgets like <a>ColumnView</a>,
--   otherwise it behaves like <tt>GTK_LIST_TAB_ITEM</tt>.
ListTabBehaviorCell :: ListTabBehavior

-- | Catch-all for unknown values
AnotherListTabBehavior :: Int -> ListTabBehavior

-- | The type of message being displayed in a
--   [class<i><tt>messageDialog</tt></i>].
data MessageType

-- | Informational message
MessageTypeInfo :: MessageType

-- | Non-fatal warning message
MessageTypeWarning :: MessageType

-- | Question requiring a choice
MessageTypeQuestion :: MessageType

-- | Fatal error message
MessageTypeError :: MessageType

-- | None of the above
MessageTypeOther :: MessageType

-- | Catch-all for unknown values
AnotherMessageType :: Int -> MessageType

-- | Passed as argument to various keybinding signals for moving the cursor
--   position.
data MovementStep

-- | Move forward or back by graphemes
MovementStepLogicalPositions :: MovementStep

-- | Move left or right by graphemes
MovementStepVisualPositions :: MovementStep

-- | Move forward or back by words
MovementStepWords :: MovementStep

-- | Move up or down lines (wrapped lines)
MovementStepDisplayLines :: MovementStep

-- | Move to either end of a line
MovementStepDisplayLineEnds :: MovementStep

-- | Move up or down paragraphs (newline-ended lines)
MovementStepParagraphs :: MovementStep

-- | Move to either end of a paragraph
MovementStepParagraphEnds :: MovementStep

-- | Move by pages
MovementStepPages :: MovementStep

-- | Move to ends of the buffer
MovementStepBufferEnds :: MovementStep

-- | Move horizontally by pages
MovementStepHorizontalPages :: MovementStep

-- | Catch-all for unknown values
AnotherMovementStep :: Int -> MovementStep

-- | Options for selecting a different wrap mode for natural size requests.
--   
--   See for example the <a>Label:naturalWrapMode</a> property.
--   
--   <i>Since: 4.6</i>
data NaturalWrapMode

-- | Inherit the minimum size request. In particular, this should be used
--   with <a>WrapModeChar</a>.
NaturalWrapModeInherit :: NaturalWrapMode

-- | Try not to wrap the text. This mode is the closest to GTK3's behavior
--   but can lead to a wide label leaving lots of empty space below the
--   text.
NaturalWrapModeNone :: NaturalWrapMode

-- | Attempt to wrap at word boundaries. This is useful in particular when
--   using <a>WrapModeWordChar</a> as the wrap mode.
NaturalWrapModeWord :: NaturalWrapMode

-- | Catch-all for unknown values
AnotherNaturalWrapMode :: Int -> NaturalWrapMode

-- | The parameter used in the action signals of <tt>GtkNotebook</tt>.
data NotebookTab

-- | the first tab in the notebook
NotebookTabFirst :: NotebookTab

-- | the last tab in the notebook
NotebookTabLast :: NotebookTab

-- | Catch-all for unknown values
AnotherNotebookTab :: Int -> NotebookTab

-- | Used to determine the layout of pages on a sheet when printing
--   multiple pages per sheet.
data NumberUpLayout

NumberUpLayoutLrtb :: NumberUpLayout

NumberUpLayoutLrbt :: NumberUpLayout

NumberUpLayoutRltb :: NumberUpLayout

NumberUpLayoutRlbt :: NumberUpLayout

NumberUpLayoutTblr :: NumberUpLayout

NumberUpLayoutTbrl :: NumberUpLayout

NumberUpLayoutBtlr :: NumberUpLayout

NumberUpLayoutBtrl :: NumberUpLayout

-- | Catch-all for unknown values
AnotherNumberUpLayout :: Int -> NumberUpLayout

-- | Describes the way two values can be compared.
--   
--   These values can be used with a
--   [callback<i><tt>gLib</tt></i>.CompareFunc]. However, a
--   <tt>GCompareFunc</tt> is allowed to return any integer values. For
--   converting such a value to a <tt>GtkOrdering</tt> value, use
--   <a>Ordering</a>.<tt><i>from_cmpfunc</i></tt>().
data Ordering

-- | the first value is smaller than the second
OrderingSmaller :: Ordering

-- | the two values are equal
OrderingEqual :: Ordering

-- | the first value is larger than the second
OrderingLarger :: Ordering

-- | Catch-all for unknown values
AnotherOrdering :: Int -> Ordering

-- | Represents the orientation of widgets and other objects.
--   
--   Typical examples are [class<i><tt>box</tt></i>] or
--   [class<i><tt>gesturePan</tt></i>].
data Orientation

-- | The element is in horizontal orientation.
OrientationHorizontal :: Orientation

-- | The element is in vertical orientation.
OrientationVertical :: Orientation

-- | Catch-all for unknown values
AnotherOrientation :: Int -> Orientation

-- | Defines how content overflowing a given area should be handled.
--   
--   This is used in <a>widgetSetOverflow</a>. The <a>Widget:overflow</a>
--   property is modeled after the CSS overflow property, but implements it
--   only partially.
data Overflow

-- | No change is applied. Content is drawn at the specified position.
OverflowVisible :: Overflow

-- | Content is clipped to the bounds of the area. Content outside the area
--   is not drawn and cannot be interacted with.
OverflowHidden :: Overflow

-- | Catch-all for unknown values
AnotherOverflow :: Int -> Overflow

-- | Represents the packing location of a children in its parent.
--   
--   See [class<i><tt>windowControls</tt></i>] for example.
data PackType

-- | The child is packed into the start of the widget
PackTypeStart :: PackType

-- | The child is packed into the end of the widget
PackTypeEnd :: PackType

-- | Catch-all for unknown values
AnotherPackType :: Int -> PackType

-- | The type of a pad action.
data PadActionType

-- | Action is triggered by a pad button
PadActionTypeButton :: PadActionType

-- | Action is triggered by a pad ring
PadActionTypeRing :: PadActionType

-- | Action is triggered by a pad strip
PadActionTypeStrip :: PadActionType

-- | Action is triggered by a pad dial
PadActionTypeDial :: PadActionType

-- | Catch-all for unknown values
AnotherPadActionType :: Int -> PadActionType

-- | See also <a>printSettingsSetOrientation</a>.
data PageOrientation

-- | Portrait mode.
PageOrientationPortrait :: PageOrientation

-- | Landscape mode.
PageOrientationLandscape :: PageOrientation

-- | Reverse portrait mode.
PageOrientationReversePortrait :: PageOrientation

-- | Reverse landscape mode.
PageOrientationReverseLandscape :: PageOrientation

-- | Catch-all for unknown values
AnotherPageOrientation :: Int -> PageOrientation

-- | See also <a>printJobSetPageSet</a>.
data PageSet

-- | All pages.
PageSetAll :: PageSet

-- | Even pages.
PageSetEven :: PageSet

-- | Odd pages.
PageSetOdd :: PageSet

-- | Catch-all for unknown values
AnotherPageSet :: Int -> PageSet

-- | Describes the panning direction of a
--   [class<i><tt>gesturePan</tt></i>].
data PanDirection

-- | panned towards the left
PanDirectionLeft :: PanDirection

-- | panned towards the right
PanDirectionRight :: PanDirection

-- | panned upwards
PanDirectionUp :: PanDirection

-- | panned downwards
PanDirectionDown :: PanDirection

-- | Catch-all for unknown values
AnotherPanDirection :: Int -> PanDirection

-- | Determines how the size should be computed to achieve the one of the
--   visibility mode for the scrollbars.
data PolicyType

-- | The scrollbar is always visible. The view size is independent of the
--   content.
PolicyTypeAlways :: PolicyType

-- | The scrollbar will appear and disappear as necessary. For example,
--   when all of a <tt>GtkTreeView</tt> can not be seen.
PolicyTypeAutomatic :: PolicyType

-- | The scrollbar should never appear. In this mode the content determines
--   the size.
PolicyTypeNever :: PolicyType

-- | Don't show a scrollbar, but don't force the size to follow the
--   content. This can be used e.g. to make multiple scrolled windows share
--   a scrollbar.
PolicyTypeExternal :: PolicyType

-- | Catch-all for unknown values
AnotherPolicyType :: Int -> PolicyType

-- | Describes which edge of a widget a certain feature is positioned at.
--   
--   For examples, see the tabs of a [class<i><tt>notebook</tt></i>], or
--   the label of a [class<i><tt>scale</tt></i>].
data PositionType

-- | The feature is at the left edge.
PositionTypeLeft :: PositionType

-- | The feature is at the right edge.
PositionTypeRight :: PositionType

-- | The feature is at the top edge.
PositionTypeTop :: PositionType

-- | The feature is at the bottom edge.
PositionTypeBottom :: PositionType

-- | Catch-all for unknown values
AnotherPositionType :: Int -> PositionType

-- | See also <a>printSettingsSetDuplex</a>.
data PrintDuplex

-- | No duplex.
PrintDuplexSimplex :: PrintDuplex

-- | Horizontal duplex.
PrintDuplexHorizontal :: PrintDuplex

-- | Vertical duplex.
PrintDuplexVertical :: PrintDuplex

-- | Catch-all for unknown values
AnotherPrintDuplex :: Int -> PrintDuplex

-- | Error codes that identify various errors that can occur while using
--   the GTK printing support.
data PrintError

-- | An unspecified error occurred.
PrintErrorGeneral :: PrintError

-- | An internal error occurred.
PrintErrorInternalError :: PrintError

-- | A memory allocation failed.
PrintErrorNomem :: PrintError

-- | An error occurred while loading a page setup or paper size from a key
--   file.
PrintErrorInvalidFile :: PrintError

-- | Catch-all for unknown values
AnotherPrintError :: Int -> PrintError

-- | Catch exceptions of type <a>PrintError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchPrintError :: IO a -> (PrintError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>PrintError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handlePrintError :: (PrintError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Determines what action the print operation should perform.
--   
--   A parameter of this typs is passed to <a>printOperationRun</a>.
data PrintOperationAction

-- | Show the print dialog.
PrintOperationActionPrintDialog :: PrintOperationAction

-- | Start to print without showing the print dialog, based on the current
--   print settings, if possible. Depending on the platform, a print dialog
--   might appear anyway.
PrintOperationActionPrint :: PrintOperationAction

-- | Show the print preview.
PrintOperationActionPreview :: PrintOperationAction

-- | Export to a file. This requires the export-filename property to be
--   set.
PrintOperationActionExport :: PrintOperationAction

-- | Catch-all for unknown values
AnotherPrintOperationAction :: Int -> PrintOperationAction

-- | The result of a print operation.
--   
--   A value of this type is returned by <a>printOperationRun</a>.
data PrintOperationResult

-- | An error has occurred.
PrintOperationResultError :: PrintOperationResult

-- | The print settings should be stored.
PrintOperationResultApply :: PrintOperationResult

-- | The print operation has been canceled, the print settings should not
--   be stored.
PrintOperationResultCancel :: PrintOperationResult

-- | The print operation is not complete yet. This value will only be
--   returned when running asynchronously.
PrintOperationResultInProgress :: PrintOperationResult

-- | Catch-all for unknown values
AnotherPrintOperationResult :: Int -> PrintOperationResult

-- | See also <a>printJobSetPages</a>
data PrintPages

-- | All pages.
PrintPagesAll :: PrintPages

-- | Current page.
PrintPagesCurrent :: PrintPages

-- | Range of pages.
PrintPagesRanges :: PrintPages

-- | Selected pages.
PrintPagesSelection :: PrintPages

-- | Catch-all for unknown values
AnotherPrintPages :: Int -> PrintPages

-- | See also <a>printSettingsSetQuality</a>.
data PrintQuality

-- | Low quality.
PrintQualityLow :: PrintQuality

-- | Normal quality.
PrintQualityNormal :: PrintQuality

-- | High quality.
PrintQualityHigh :: PrintQuality

-- | Draft quality.
PrintQualityDraft :: PrintQuality

-- | Catch-all for unknown values
AnotherPrintQuality :: Int -> PrintQuality

-- | The status gives a rough indication of the completion of a running
--   print operation.
data PrintStatus

-- | The printing has not started yet; this status is set initially, and
--   while the print dialog is shown.
PrintStatusInitial :: PrintStatus

-- | This status is set while the begin-print signal is emitted and during
--   pagination.
PrintStatusPreparing :: PrintStatus

-- | This status is set while the pages are being rendered.
PrintStatusGeneratingData :: PrintStatus

-- | The print job is being sent off to the printer.
PrintStatusSendingData :: PrintStatus

-- | The print job has been sent to the printer, but is not printed for
--   some reason, e.g. the printer may be stopped.
PrintStatusPending :: PrintStatus

-- | Some problem has occurred during printing, e.g. a paper jam.
PrintStatusPendingIssue :: PrintStatus

-- | The printer is processing the print job.
PrintStatusPrinting :: PrintStatus

-- | The printing has been completed successfully.
PrintStatusFinished :: PrintStatus

-- | The printing has been aborted.
PrintStatusFinishedAborted :: PrintStatus

-- | Catch-all for unknown values
AnotherPrintStatus :: Int -> PrintStatus

-- | Describes limits of a [class<i><tt>eventController</tt></i>] for
--   handling events targeting other widgets.
data PropagationLimit

-- | Events are handled regardless of what their target is.
PropagationLimitNone :: PropagationLimit

-- | Events are only handled if their target is in the same
--   [iface<i><tt>native</tt></i>] (or widget with
--   <a>Widget:limitEvents</a> set) as the event controllers widget. Note
--   that some event types have two targets (origin and destination).
PropagationLimitSameNative :: PropagationLimit

-- | Catch-all for unknown values
AnotherPropagationLimit :: Int -> PropagationLimit

-- | Describes the stage at which events are fed into a
--   [class<i><tt>eventController</tt></i>].
data PropagationPhase

-- | Events are not delivered.
PropagationPhaseNone :: PropagationPhase

-- | Events are delivered in the capture phase. The capture phase happens
--   before the bubble phase, runs from the toplevel down to the event
--   widget. This option should only be used on containers that might
--   possibly handle events before their children do.
PropagationPhaseCapture :: PropagationPhase

-- | Events are delivered in the bubble phase. The bubble phase happens
--   after the capture phase, and before the default handlers are run. This
--   phase runs from the event widget, up to the toplevel.
PropagationPhaseBubble :: PropagationPhase

-- | Events are delivered in the default widget event handlers, note that
--   widget implementations must chain up on button, motion, touch and grab
--   broken handlers for controllers in this phase to be run.
PropagationPhaseTarget :: PropagationPhase

-- | Catch-all for unknown values
AnotherPropagationPhase :: Int -> PropagationPhase

-- | Error codes for <tt>GtkRecentManager</tt> operations
data RecentManagerError

-- | the URI specified does not exists in the recently used resources list.
RecentManagerErrorNotFound :: RecentManagerError

-- | the URI specified is not valid.
RecentManagerErrorInvalidUri :: RecentManagerError

-- | the supplied string is not UTF-8 encoded.
RecentManagerErrorInvalidEncoding :: RecentManagerError

-- | no application has registered the specified item.
RecentManagerErrorNotRegistered :: RecentManagerError

-- | failure while reading the recently used resources file.
RecentManagerErrorRead :: RecentManagerError

-- | failure while writing the recently used resources file.
RecentManagerErrorWrite :: RecentManagerError

-- | unspecified error.
RecentManagerErrorUnknown :: RecentManagerError

-- | Catch-all for unknown values
AnotherRecentManagerError :: Int -> RecentManagerError

-- | Catch exceptions of type <a>RecentManagerError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchRecentManagerError :: IO a -> (RecentManagerError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>RecentManagerError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleRecentManagerError :: (RecentManagerError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Values for the <a>Settings:gtkInterfaceReducedMotion</a> and
--   <a>CssProvider:prefersReducedMotion</a> properties that indicates the
--   preferred level of motion animations.
--   
--   This information can be used inside CSS via media queries.
--   
--   <i>Since: 4.22</i>
data ReducedMotion

-- | The user has made no preference known to the system
ReducedMotionNoPreference :: ReducedMotion

-- | The user has notified the system that they prefer an interface that
--   removes or replaces the types of motion-based animation that either
--   trigger discomfort for those with vestibular motion sensitivity, or
--   distraction for those with attention deficits
ReducedMotionReduce :: ReducedMotion

-- | Catch-all for unknown values
AnotherReducedMotion :: Int -> ReducedMotion

-- | Predefined values for use as response ids in <a>dialogAddButton</a>.
--   
--   All predefined values are negative; GTK leaves values of 0 or greater
--   for application-defined response ids.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data ResponseType

-- | Returned if an action widget has no response id, or if the dialog gets
--   programmatically hidden or destroyed
ResponseTypeNone :: ResponseType

-- | Generic response id, not used by GTK dialogs
ResponseTypeReject :: ResponseType

-- | Generic response id, not used by GTK dialogs
ResponseTypeAccept :: ResponseType

-- | Returned if the dialog is deleted
ResponseTypeDeleteEvent :: ResponseType

-- | Returned by OK buttons in GTK dialogs
ResponseTypeOk :: ResponseType

-- | Returned by Cancel buttons in GTK dialogs
ResponseTypeCancel :: ResponseType

-- | Returned by Close buttons in GTK dialogs
ResponseTypeClose :: ResponseType

-- | Returned by Yes buttons in GTK dialogs
ResponseTypeYes :: ResponseType

-- | Returned by No buttons in GTK dialogs
ResponseTypeNo :: ResponseType

-- | Returned by Apply buttons in GTK dialogs
ResponseTypeApply :: ResponseType

-- | Returned by Help buttons in GTK dialogs
ResponseTypeHelp :: ResponseType

-- | Catch-all for unknown values
AnotherResponseType :: Int -> ResponseType

-- | These enumeration values describe the possible transitions when the
--   child of a <tt>GtkRevealer</tt> widget is shown or hidden.
data RevealerTransitionType

-- | No transition
RevealerTransitionTypeNone :: RevealerTransitionType

-- | Fade in
RevealerTransitionTypeCrossfade :: RevealerTransitionType

-- | Slide in from the left
RevealerTransitionTypeSlideRight :: RevealerTransitionType

-- | Slide in from the right
RevealerTransitionTypeSlideLeft :: RevealerTransitionType

-- | Slide in from the bottom
RevealerTransitionTypeSlideUp :: RevealerTransitionType

-- | Slide in from the top
RevealerTransitionTypeSlideDown :: RevealerTransitionType

-- | Floop in from the left
RevealerTransitionTypeSwingRight :: RevealerTransitionType

-- | Floop in from the right
RevealerTransitionTypeSwingLeft :: RevealerTransitionType

-- | Floop in from the bottom
RevealerTransitionTypeSwingUp :: RevealerTransitionType

-- | Floop in from the top
RevealerTransitionTypeSwingDown :: RevealerTransitionType

-- | Combination of <a>RevealerTransitionTypeCrossfade</a> and
--   <a>RevealerTransitionTypeSlideRight</a>.
--   
--   <i>Since: 4.22</i>
RevealerTransitionTypeFadeSlideRight :: RevealerTransitionType

-- | Combination of <a>RevealerTransitionTypeCrossfade</a> and
--   <a>RevealerTransitionTypeSlideLeft</a>.
--   
--   <i>Since: 4.22</i>
RevealerTransitionTypeFadeSlideLeft :: RevealerTransitionType

-- | Combination of <a>RevealerTransitionTypeCrossfade</a> and
--   <a>RevealerTransitionTypeSlideUp</a>.
--   
--   <i>Since: 4.22</i>
RevealerTransitionTypeFadeSlideUp :: RevealerTransitionType

-- | Combination of <a>RevealerTransitionTypeCrossfade</a> and
--   <a>RevealerTransitionTypeSlideDown</a>.
--   
--   <i>Since: 4.22</i>
RevealerTransitionTypeFadeSlideDown :: RevealerTransitionType

-- | Catch-all for unknown values
AnotherRevealerTransitionType :: Int -> RevealerTransitionType

-- | Passed as argument to various keybinding signals.
data ScrollStep

-- | Scroll in steps.
ScrollStepSteps :: ScrollStep

-- | Scroll by pages.
ScrollStepPages :: ScrollStep

-- | Scroll to ends.
ScrollStepEnds :: ScrollStep

-- | Scroll in horizontal steps.
ScrollStepHorizontalSteps :: ScrollStep

-- | Scroll by horizontal pages.
ScrollStepHorizontalPages :: ScrollStep

-- | Scroll to the horizontal ends.
ScrollStepHorizontalEnds :: ScrollStep

-- | Catch-all for unknown values
AnotherScrollStep :: Int -> ScrollStep

-- | Scrolling types.
data ScrollType

-- | No scrolling.
ScrollTypeNone :: ScrollType

-- | Jump to new location.
ScrollTypeJump :: ScrollType

-- | Step backward.
ScrollTypeStepBackward :: ScrollType

-- | Step forward.
ScrollTypeStepForward :: ScrollType

-- | Page backward.
ScrollTypePageBackward :: ScrollType

-- | Page forward.
ScrollTypePageForward :: ScrollType

-- | Step up.
ScrollTypeStepUp :: ScrollType

-- | Step down.
ScrollTypeStepDown :: ScrollType

-- | Page up.
ScrollTypePageUp :: ScrollType

-- | Page down.
ScrollTypePageDown :: ScrollType

-- | Step to the left.
ScrollTypeStepLeft :: ScrollType

-- | Step to the right.
ScrollTypeStepRight :: ScrollType

-- | Page to the left.
ScrollTypePageLeft :: ScrollType

-- | Page to the right.
ScrollTypePageRight :: ScrollType

-- | Scroll to start.
ScrollTypeStart :: ScrollType

-- | Scroll to end.
ScrollTypeEnd :: ScrollType

-- | Catch-all for unknown values
AnotherScrollType :: Int -> ScrollType

-- | Defines the policy to be used in a scrollable widget when updating the
--   scrolled window adjustments in a given orientation.
data ScrollablePolicy

-- | Scrollable adjustments are based on the minimum size
ScrollablePolicyMinimum :: ScrollablePolicy

-- | Scrollable adjustments are based on the natural size
ScrollablePolicyNatural :: ScrollablePolicy

-- | Catch-all for unknown values
AnotherScrollablePolicy :: Int -> ScrollablePolicy

-- | Used to control what selections users are allowed to make.
data SelectionMode

-- | No selection is possible.
SelectionModeNone :: SelectionMode

-- | Zero or one element may be selected.
SelectionModeSingle :: SelectionMode

-- | Exactly one element is selected. In some circumstances, such as
--   initially or during a search operation, it’s possible for no element
--   to be selected with <a>SelectionModeBrowse</a>. What is really
--   enforced is that the user can’t deselect a currently selected element
--   except by selecting another element.
SelectionModeBrowse :: SelectionMode

-- | Any number of elements may be selected. The Ctrl key may be used to
--   enlarge the selection, and Shift key to select between the focus and
--   the child pointed to. Some widgets may also allow Click-drag to select
--   a range of elements.
SelectionModeMultiple :: SelectionMode

-- | Catch-all for unknown values
AnotherSelectionMode :: Int -> SelectionMode

-- | Determines how GTK handles the sensitivity of various controls, such
--   as combo box buttons.
data SensitivityType

-- | The control is made insensitive if no action can be triggered
SensitivityTypeAuto :: SensitivityType

-- | The control is always sensitive
SensitivityTypeOn :: SensitivityType

-- | The control is always insensitive
SensitivityTypeOff :: SensitivityType

-- | Catch-all for unknown values
AnotherSensitivityType :: Int -> SensitivityType

-- | Describes where [class<i><tt>shortcut</tt></i>]s added to a
--   [class<i><tt>shortcutController</tt></i>] get handled.
data ShortcutScope

-- | Shortcuts are handled inside the widget the controller belongs to.
ShortcutScopeLocal :: ShortcutScope

-- | Shortcuts are handled by the first ancestor that is a
--   [iface<i><tt>shortcutManager</tt></i>]
ShortcutScopeManaged :: ShortcutScope

-- | Shortcuts are handled by the root widget.
ShortcutScopeGlobal :: ShortcutScope

-- | Catch-all for unknown values
AnotherShortcutScope :: Int -> ShortcutScope

-- | GtkShortcutType specifies the kind of shortcut that is being
--   described.
--   
--   More values may be added to this enumeration over time.
data ShortcutType

-- | The shortcut is a keyboard accelerator. The
--   GtkShortcutsShortcut:accelerator property will be used.
ShortcutTypeAccelerator :: ShortcutType

-- | The shortcut is a pinch gesture. GTK provides an icon and subtitle.
ShortcutTypeGesturePinch :: ShortcutType

-- | The shortcut is a stretch gesture. GTK provides an icon and subtitle.
ShortcutTypeGestureStretch :: ShortcutType

-- | The shortcut is a clockwise rotation gesture. GTK provides an icon and
--   subtitle.
ShortcutTypeGestureRotateClockwise :: ShortcutType

-- | The shortcut is a counterclockwise rotation gesture. GTK provides an
--   icon and subtitle.
ShortcutTypeGestureRotateCounterclockwise :: ShortcutType

-- | The shortcut is a two-finger swipe gesture. GTK provides an icon and
--   subtitle.
ShortcutTypeGestureTwoFingerSwipeLeft :: ShortcutType

-- | The shortcut is a two-finger swipe gesture. GTK provides an icon and
--   subtitle.
ShortcutTypeGestureTwoFingerSwipeRight :: ShortcutType

-- | The shortcut is a gesture. The GtkShortcutsShortcut:icon property will
--   be used.
ShortcutTypeGesture :: ShortcutType

-- | The shortcut is a swipe gesture. GTK provides an icon and subtitle.
ShortcutTypeGestureSwipeLeft :: ShortcutType

-- | The shortcut is a swipe gesture. GTK provides an icon and subtitle.
ShortcutTypeGestureSwipeRight :: ShortcutType

-- | Catch-all for unknown values
AnotherShortcutType :: Int -> ShortcutType

-- | The mode of the size group determines the directions in which the size
--   group affects the requested sizes of its component widgets.
data SizeGroupMode

-- | group has no effect
SizeGroupModeNone :: SizeGroupMode

-- | group affects horizontal requisition
SizeGroupModeHorizontal :: SizeGroupMode

-- | group affects vertical requisition
SizeGroupModeVertical :: SizeGroupMode

-- | group affects both horizontal and vertical requisition
SizeGroupModeBoth :: SizeGroupMode

-- | Catch-all for unknown values
AnotherSizeGroupMode :: Int -> SizeGroupMode

-- | Specifies a preference for height-for-width or width-for-height
--   geometry management.
data SizeRequestMode

-- | Prefer height-for-width geometry management
SizeRequestModeHeightForWidth :: SizeRequestMode

-- | Prefer width-for-height geometry management
SizeRequestModeWidthForHeight :: SizeRequestMode

-- | Don’t trade height-for-width or width-for-height
SizeRequestModeConstantSize :: SizeRequestMode

-- | Catch-all for unknown values
AnotherSizeRequestMode :: Int -> SizeRequestMode

-- | Determines the direction of a sort.
data SortType

-- | Sorting is in ascending order.
SortTypeAscending :: SortType

-- | Sorting is in descending order.
SortTypeDescending :: SortType

-- | Catch-all for unknown values
AnotherSortType :: Int -> SortType

-- | Describes changes in a sorter in more detail and allows users to
--   optimize resorting.
data SorterChange

-- | The sorter change cannot be described by any of the other enumeration
--   values
SorterChangeDifferent :: SorterChange

-- | The sort order was inverted. Comparisons that returned
--   <a>OrderingSmaller</a> now return <a>OrderingLarger</a> and vice
--   versa. Other comparisons return the same values as before.
SorterChangeInverted :: SorterChange

-- | The sorter is less strict: Comparisons may now return
--   <a>OrderingEqual</a> that did not do so before.
SorterChangeLessStrict :: SorterChange

-- | The sorter is more strict: Comparisons that did return
--   <a>OrderingEqual</a> may not do so anymore.
SorterChangeMoreStrict :: SorterChange

-- | Catch-all for unknown values
AnotherSorterChange :: Int -> SorterChange

-- | Describes the type of order that a <tt>GtkSorter</tt> may produce.
data SorterOrder

-- | A partial order. Any <tt>GtkOrdering</tt> is possible.
SorterOrderPartial :: SorterOrder

-- | No order, all elements are considered equal. <a>sorterCompare</a> will
--   only return <a>OrderingEqual</a>.
SorterOrderNone :: SorterOrder

-- | A total order. <a>sorterCompare</a> will only return
--   <a>OrderingEqual</a> if an item is compared with itself. Two different
--   items will never cause this value to be returned.
SorterOrderTotal :: SorterOrder

-- | Catch-all for unknown values
AnotherSorterOrder :: Int -> SorterOrder

-- | Determines whether the spin button displays values outside the
--   adjustment bounds.
--   
--   See <a>spinButtonSetUpdatePolicy</a>.
data SpinButtonUpdatePolicy

-- | When refreshing your <tt>GtkSpinButton</tt>, the value is always
--   displayed
SpinButtonUpdatePolicyAlways :: SpinButtonUpdatePolicy

-- | When refreshing your <tt>GtkSpinButton</tt>, the value is only
--   displayed if it is valid within the bounds of the spin button's
--   adjustment
SpinButtonUpdatePolicyIfValid :: SpinButtonUpdatePolicy

-- | Catch-all for unknown values
AnotherSpinButtonUpdatePolicy :: Int -> SpinButtonUpdatePolicy

-- | The values of the GtkSpinType enumeration are used to specify the
--   change to make in <a>spinButtonSpin</a>.
data SpinType

-- | Increment by the adjustments step increment.
SpinTypeStepForward :: SpinType

-- | Decrement by the adjustments step increment.
SpinTypeStepBackward :: SpinType

-- | Increment by the adjustments page increment.
SpinTypePageForward :: SpinType

-- | Decrement by the adjustments page increment.
SpinTypePageBackward :: SpinType

-- | Go to the adjustments lower bound.
SpinTypeHome :: SpinType

-- | Go to the adjustments upper bound.
SpinTypeEnd :: SpinType

-- | Change by a specified amount.
SpinTypeUserDefined :: SpinType

-- | Catch-all for unknown values
AnotherSpinType :: Int -> SpinType

-- | Possible transitions between pages in a <tt>GtkStack</tt> widget.
--   
--   New values may be added to this enumeration over time.
data StackTransitionType

-- | No transition
StackTransitionTypeNone :: StackTransitionType

-- | A cross-fade
StackTransitionTypeCrossfade :: StackTransitionType

-- | Slide from left to right
StackTransitionTypeSlideRight :: StackTransitionType

-- | Slide from right to left
StackTransitionTypeSlideLeft :: StackTransitionType

-- | Slide from bottom up
StackTransitionTypeSlideUp :: StackTransitionType

-- | Slide from top down
StackTransitionTypeSlideDown :: StackTransitionType

-- | Slide from left or right according to the children order
StackTransitionTypeSlideLeftRight :: StackTransitionType

-- | Slide from top down or bottom up according to the order
StackTransitionTypeSlideUpDown :: StackTransitionType

-- | Cover the old page by sliding up
StackTransitionTypeOverUp :: StackTransitionType

-- | Cover the old page by sliding down
StackTransitionTypeOverDown :: StackTransitionType

-- | Cover the old page by sliding to the left
StackTransitionTypeOverLeft :: StackTransitionType

-- | Cover the old page by sliding to the right
StackTransitionTypeOverRight :: StackTransitionType

-- | Uncover the new page by sliding up
StackTransitionTypeUnderUp :: StackTransitionType

-- | Uncover the new page by sliding down
StackTransitionTypeUnderDown :: StackTransitionType

-- | Uncover the new page by sliding to the left
StackTransitionTypeUnderLeft :: StackTransitionType

-- | Uncover the new page by sliding to the right
StackTransitionTypeUnderRight :: StackTransitionType

-- | Cover the old page sliding up or uncover the new page sliding down,
--   according to order
StackTransitionTypeOverUpDown :: StackTransitionType

-- | Cover the old page sliding down or uncover the new page sliding up,
--   according to order
StackTransitionTypeOverDownUp :: StackTransitionType

-- | Cover the old page sliding left or uncover the new page sliding right,
--   according to order
StackTransitionTypeOverLeftRight :: StackTransitionType

-- | Cover the old page sliding right or uncover the new page sliding left,
--   according to order
StackTransitionTypeOverRightLeft :: StackTransitionType

-- | Pretend the pages are sides of a cube and rotate that cube to the left
StackTransitionTypeRotateLeft :: StackTransitionType

-- | Pretend the pages are sides of a cube and rotate that cube to the
--   right
StackTransitionTypeRotateRight :: StackTransitionType

-- | Pretend the pages are sides of a cube and rotate that cube to the left
--   or right according to the children order
StackTransitionTypeRotateLeftRight :: StackTransitionType

-- | Catch-all for unknown values
AnotherStackTransitionType :: Int -> StackTransitionType

-- | Specifies how search strings are matched inside text.
data StringFilterMatchMode

-- | The search string and text must match exactly
StringFilterMatchModeExact :: StringFilterMatchMode

-- | The search string must be contained as a substring inside the text
StringFilterMatchModeSubstring :: StringFilterMatchMode

-- | The text must begin with the search string
StringFilterMatchModePrefix :: StringFilterMatchMode

-- | Catch-all for unknown values
AnotherStringFilterMatchMode :: Int -> StringFilterMatchMode

-- | Error codes in the <tt>GTK_SVG_ERROR</tt> domain for errors that
--   happen during parsing or rendering of SVG.
--   
--   <i>Since: 4.22</i>
data SvgError

-- | The XML syntax is broken in some way
SvgErrorInvalidSyntax :: SvgError

-- | An XML element is invalid (either because it is not part of SVG, or
--   because it is in the wrong place, or because it not implemented in
--   GTK)
SvgErrorInvalidElement :: SvgError

-- | An attribute is invalid (either because it is not part of SVG, or
--   because it is not implemented in GTK, or its value is problematic)
SvgErrorInvalidAttribute :: SvgError

-- | A required attribute is missing
SvgErrorMissingAttribute :: SvgError

-- | A reference does not point to a suitable element
SvgErrorInvalidReference :: SvgError

-- | An animation could not be updated
SvgErrorFailedUpdate :: SvgError

-- | Rendering is not according to expecations
SvgErrorFailedRendering :: SvgError

-- | Catch-all for unknown values
AnotherSvgError :: Int -> SvgError

-- | Catch exceptions of type <a>SvgError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchSvgError :: IO a -> (SvgError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>SvgError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleSvgError :: (SvgError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | The indexes of colors passed to symbolic color rendering, such as
--   <a>SymbolicPaintable</a>.<tt><i>snapshot_symbolic</i></tt>().
--   
--   More values may be added over time.
--   
--   <i>Since: 4.6</i>
data SymbolicColor

-- | The default foreground color
SymbolicColorForeground :: SymbolicColor

-- | Indication color for errors
SymbolicColorError :: SymbolicColor

-- | Indication color for warnings
SymbolicColorWarning :: SymbolicColor

-- | Indication color for success
SymbolicColorSuccess :: SymbolicColor

-- | The system accent color.
--   
--   <i>Since: 4.22</i>
SymbolicColorAccent :: SymbolicColor

-- | Catch-all for unknown values
AnotherSymbolicColor :: Int -> SymbolicColor

-- | Values that can be passed to the
--   <a>Widget</a>.<tt><i>system_setting_changed</i></tt>() vfunc.
--   
--   The values indicate which system setting has changed. Widgets may need
--   to drop caches, or react otherwise.
--   
--   Most of the values correspond to [class<i><tt>settings</tt></i>]
--   properties.
--   
--   More values may be added over time.
data SystemSetting

-- | the <a>Settings:gtkXftDpi</a> setting has changed
SystemSettingDpi :: SystemSetting

-- | The <a>Settings:gtkFontName</a> setting has changed
SystemSettingFontName :: SystemSetting

-- | The font configuration has changed in a way that requires text to be
--   redrawn. This can be any of the <a>Settings:gtkXftAntialias</a>,
--   <a>Settings:gtkXftHinting</a>, <a>Settings:gtkXftHintstyle</a>,
--   <a>Settings:gtkXftRgba</a> or <a>Settings:gtkFontconfigTimestamp</a>
--   settings
SystemSettingFontConfig :: SystemSetting

-- | The display has changed
SystemSettingDisplay :: SystemSetting

-- | The icon theme has changed in a way that requires icons to be looked
--   up again
SystemSettingIconTheme :: SystemSetting

-- | Catch-all for unknown values
AnotherSystemSetting :: Int -> SystemSetting

-- | Reading directions for text.
data TextDirection

-- | No direction.
TextDirectionNone :: TextDirection

-- | Left to right text direction.
TextDirectionLtr :: TextDirection

-- | Right to left text direction.
TextDirectionRtl :: TextDirection

-- | Catch-all for unknown values
AnotherTextDirection :: Int -> TextDirection

-- | Granularity types that extend the text selection. Use the
--   <tt>GtkTextView::extend-selection</tt> signal to customize the
--   selection.
data TextExtendSelection

-- | Selects the current word. It is triggered by a double-click for
--   example.
TextExtendSelectionWord :: TextExtendSelection

-- | Selects the current line. It is triggered by a triple-click for
--   example.
TextExtendSelectionLine :: TextExtendSelection

-- | Catch-all for unknown values
AnotherTextExtendSelection :: Int -> TextExtendSelection

-- | Used to reference the layers of <tt>GtkTextView</tt> for the purpose
--   of customized drawing with the <a>snapshot_layer</a> vfunc.
data TextViewLayer

-- | The layer rendered below the text (but above the background).
TextViewLayerBelowText :: TextViewLayer

-- | The layer rendered above the text.
TextViewLayerAboveText :: TextViewLayer

-- | Catch-all for unknown values
AnotherTextViewLayer :: Int -> TextViewLayer

-- | Used to reference the parts of <tt>GtkTextView</tt>.
data TextWindowType

-- | Window that floats over scrolling areas.
TextWindowTypeWidget :: TextWindowType

-- | Scrollable text window.
TextWindowTypeText :: TextWindowType

-- | Left side border window.
TextWindowTypeLeft :: TextWindowType

-- | Right side border window.
TextWindowTypeRight :: TextWindowType

-- | Top border window.
TextWindowTypeTop :: TextWindowType

-- | Bottom border window.
TextWindowTypeBottom :: TextWindowType

-- | Catch-all for unknown values
AnotherTextWindowType :: Int -> TextWindowType

-- | The sizing method the column uses to determine its width. Please note
--   that <a>TreeViewColumnSizingAutosize</a> are inefficient for large
--   views, and can make columns appear choppy.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data TreeViewColumnSizing

-- | Columns only get bigger in reaction to changes in the model
TreeViewColumnSizingGrowOnly :: TreeViewColumnSizing

-- | Columns resize to be the optimal size every time the model changes.
TreeViewColumnSizingAutosize :: TreeViewColumnSizing

-- | Columns are a fixed numbers of pixels wide.
TreeViewColumnSizingFixed :: TreeViewColumnSizing

-- | Catch-all for unknown values
AnotherTreeViewColumnSizing :: Int -> TreeViewColumnSizing

-- | An enum for determining where a dropped row goes.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data TreeViewDropPosition

-- | dropped row is inserted before
TreeViewDropPositionBefore :: TreeViewDropPosition

-- | dropped row is inserted after
TreeViewDropPositionAfter :: TreeViewDropPosition

-- | dropped row becomes a child or is inserted before
TreeViewDropPositionIntoOrBefore :: TreeViewDropPosition

-- | dropped row becomes a child or is inserted after
TreeViewDropPositionIntoOrAfter :: TreeViewDropPosition

-- | Catch-all for unknown values
AnotherTreeViewDropPosition :: Int -> TreeViewDropPosition

-- | Used to indicate which grid lines to draw in a tree view.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
data TreeViewGridLines

-- | No grid lines.
TreeViewGridLinesNone :: TreeViewGridLines

-- | Horizontal grid lines.
TreeViewGridLinesHorizontal :: TreeViewGridLines

-- | Vertical grid lines.
TreeViewGridLinesVertical :: TreeViewGridLines

-- | Horizontal and vertical grid lines.
TreeViewGridLinesBoth :: TreeViewGridLines

-- | Catch-all for unknown values
AnotherTreeViewGridLines :: Int -> TreeViewGridLines

-- | See also <a>printSettingsSetPaperWidth</a>.
data Unit

-- | No units.
UnitNone :: Unit

-- | Dimensions in points.
UnitPoints :: Unit

-- | Dimensions in inches.
UnitInch :: Unit

-- | Dimensions in millimeters
UnitMm :: Unit

-- | Catch-all for unknown values
AnotherUnit :: Int -> Unit

-- | Determines which point or edge of a window is meant to remain fixed
--   when a window changes size.
--   
--   <i>Since: 4.20</i>
data WindowGravity

-- | The top left corner
WindowGravityTopLeft :: WindowGravity

-- | The top edge
WindowGravityTop :: WindowGravity

-- | The top right corner
WindowGravityTopRight :: WindowGravity

-- | The left edge
WindowGravityLeft :: WindowGravity

-- | The center pointer
WindowGravityCenter :: WindowGravity

-- | The right edge
WindowGravityRight :: WindowGravity

-- | The bottom left corner
WindowGravityBottomLeft :: WindowGravity

-- | the bottom edge
WindowGravityBottom :: WindowGravity

-- | The bottom right corner
WindowGravityBottomRight :: WindowGravity

-- | The top left or top right corner, depending on the text direction
WindowGravityTopStart :: WindowGravity

-- | The top right or top left corner, depending on the text direction
WindowGravityTopEnd :: WindowGravity

-- | The left or right edge, depending on the text direction
WindowGravityStart :: WindowGravity

-- | The right or left edge, depending on the text direction
WindowGravityEnd :: WindowGravity

-- | The bottom left or top right corner, depending on the text direction
WindowGravityBottomStart :: WindowGravity

-- | The bottom right or top left corner, depending on the text direction
WindowGravityBottomEnd :: WindowGravity

-- | Catch-all for unknown values
AnotherWindowGravity :: Int -> WindowGravity

-- | Describes a type of line wrapping.
data WrapMode

-- | do not wrap lines; just make the text area wider
WrapModeNone :: WrapMode

-- | wrap text, breaking lines anywhere the cursor can appear (between
--   characters, usually - if you want to be technical, between graphemes,
--   see <a>getLogAttrs</a>)
WrapModeChar :: WrapMode

-- | wrap text, breaking lines in between words
WrapModeWord :: WrapMode

-- | wrap text, breaking lines in between words, or if that is not enough,
--   also between graphemes
WrapModeWordChar :: WrapMode

-- | Catch-all for unknown values
AnotherWrapMode :: Int -> WrapMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleAnnouncementPriority
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleAutocomplete
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleInvalidState
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessiblePlatformState
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleProperty
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleRelation
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleRole
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleSort
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleState
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleTextContentChange
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleTextGranularity
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AccessibleTristate
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.Align
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ArrowType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.AssistantPageType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.BaselinePosition
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.BorderStyle
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.BuilderError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ButtonsType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.CellRendererAccelMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.CellRendererMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.Collation
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ConstraintAttribute
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ConstraintRelation
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ConstraintStrength
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ConstraintVflParserError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ContentFit
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.CornerType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.DeleteType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.DialogError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.DirectionType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.EditableProperties
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.EntryIconPosition
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.EventSequenceState
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.FileChooserAction
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.FileChooserError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.FilterChange
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.FilterMatch
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.FontLevel
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.FontRendering
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.GraphicsOffloadEnabled
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.IconSize
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.IconThemeError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.IconViewDropPosition
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ImageType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.InputPurpose
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.InscriptionOverflow
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.InterfaceColorScheme
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.InterfaceContrast
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.Justification
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.LevelBarMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.License
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ListTabBehavior
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.MessageType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.MovementStep
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.NaturalWrapMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.NotebookTab
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.NumberUpLayout
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.Ordering
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.Orientation
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.Overflow
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PackType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PadActionType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PageOrientation
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PageSet
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PanDirection
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PolicyType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PositionType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PrintDuplex
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PrintError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PrintOperationAction
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PrintOperationResult
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PrintPages
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PrintQuality
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PrintStatus
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PropagationLimit
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.PropagationPhase
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.RecentManagerError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ReducedMotion
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ResponseType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.RevealerTransitionType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ScrollStep
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ScrollType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ScrollablePolicy
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SelectionMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SensitivityType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ShortcutScope
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.ShortcutType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SizeGroupMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SizeRequestMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SortType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SorterChange
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SorterOrder
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SpinButtonUpdatePolicy
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SpinType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.StackTransitionType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.StringFilterMatchMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SvgError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SymbolicColor
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.SystemSetting
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.TextDirection
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.TextExtendSelection
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.TextViewLayer
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.TextWindowType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.TreeViewColumnSizing
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.TreeViewDropPosition
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.TreeViewGridLines
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.Unit
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.WindowGravity
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gtk.Enums.WrapMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleAnnouncementPriority
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleAutocomplete
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleInvalidState
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessiblePlatformState
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleProperty
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleRelation
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleRole
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleSort
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleState
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleTextContentChange
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleTextGranularity
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AccessibleTristate
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.Align
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ArrowType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.AssistantPageType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.BaselinePosition
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.BorderStyle
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.BuilderError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ButtonsType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.CellRendererAccelMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.CellRendererMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.Collation
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ConstraintAttribute
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ConstraintRelation
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ConstraintStrength
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ConstraintVflParserError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ContentFit
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.CornerType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.CssParserError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.CssParserWarning
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.DeleteType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.DialogError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.DirectionType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.EditableProperties
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.EntryIconPosition
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.EventSequenceState
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.FileChooserAction
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.FileChooserError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.FilterChange
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.FilterMatch
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.FontLevel
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.FontRendering
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.GraphicsOffloadEnabled
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.IconSize
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.IconThemeError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.IconViewDropPosition
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ImageType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.InputPurpose
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.InscriptionOverflow
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.InterfaceColorScheme
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.InterfaceContrast
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.Justification
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.LevelBarMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.License
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ListTabBehavior
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.MessageType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.MovementStep
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.NaturalWrapMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.NotebookTab
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.NumberUpLayout
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.Ordering
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.Orientation
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.Overflow
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PackType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PadActionType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PageOrientation
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PageSet
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PanDirection
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PolicyType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PositionType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PrintDuplex
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PrintError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PrintOperationAction
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PrintOperationResult
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PrintPages
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PrintQuality
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PrintStatus
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PropagationLimit
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.PropagationPhase
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.RecentManagerError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ReducedMotion
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ResponseType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.RevealerTransitionType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ScrollStep
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ScrollType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ScrollablePolicy
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SelectionMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SensitivityType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ShortcutScope
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.ShortcutType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SizeGroupMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SizeRequestMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SortType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SorterChange
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SorterOrder
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SpinButtonUpdatePolicy
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SpinType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.StackTransitionType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.StringFilterMatchMode
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SvgError
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SymbolicColor
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.SystemSetting
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.TextDirection
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.TextExtendSelection
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.TextViewLayer
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.TextWindowType
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.TreeViewColumnSizing
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.TreeViewDropPosition
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.TreeViewGridLines
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.Unit
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.WindowGravity
instance GHC.Internal.Enum.Enum GI.Gtk.Enums.WrapMode
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleAnnouncementPriority
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleAutocomplete
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleInvalidState
instance GHC.Classes.Eq GI.Gtk.Enums.AccessiblePlatformState
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleProperty
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleRelation
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleRole
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleSort
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleState
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleTextContentChange
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleTextGranularity
instance GHC.Classes.Eq GI.Gtk.Enums.AccessibleTristate
instance GHC.Classes.Eq GI.Gtk.Enums.Align
instance GHC.Classes.Eq GI.Gtk.Enums.ArrowType
instance GHC.Classes.Eq GI.Gtk.Enums.AssistantPageType
instance GHC.Classes.Eq GI.Gtk.Enums.BaselinePosition
instance GHC.Classes.Eq GI.Gtk.Enums.BorderStyle
instance GHC.Classes.Eq GI.Gtk.Enums.BuilderError
instance GHC.Classes.Eq GI.Gtk.Enums.ButtonsType
instance GHC.Classes.Eq GI.Gtk.Enums.CellRendererAccelMode
instance GHC.Classes.Eq GI.Gtk.Enums.CellRendererMode
instance GHC.Classes.Eq GI.Gtk.Enums.Collation
instance GHC.Classes.Eq GI.Gtk.Enums.ConstraintAttribute
instance GHC.Classes.Eq GI.Gtk.Enums.ConstraintRelation
instance GHC.Classes.Eq GI.Gtk.Enums.ConstraintStrength
instance GHC.Classes.Eq GI.Gtk.Enums.ConstraintVflParserError
instance GHC.Classes.Eq GI.Gtk.Enums.ContentFit
instance GHC.Classes.Eq GI.Gtk.Enums.CornerType
instance GHC.Classes.Eq GI.Gtk.Enums.CssParserError
instance GHC.Classes.Eq GI.Gtk.Enums.CssParserWarning
instance GHC.Classes.Eq GI.Gtk.Enums.DeleteType
instance GHC.Classes.Eq GI.Gtk.Enums.DialogError
instance GHC.Classes.Eq GI.Gtk.Enums.DirectionType
instance GHC.Classes.Eq GI.Gtk.Enums.EditableProperties
instance GHC.Classes.Eq GI.Gtk.Enums.EntryIconPosition
instance GHC.Classes.Eq GI.Gtk.Enums.EventSequenceState
instance GHC.Classes.Eq GI.Gtk.Enums.FileChooserAction
instance GHC.Classes.Eq GI.Gtk.Enums.FileChooserError
instance GHC.Classes.Eq GI.Gtk.Enums.FilterChange
instance GHC.Classes.Eq GI.Gtk.Enums.FilterMatch
instance GHC.Classes.Eq GI.Gtk.Enums.FontLevel
instance GHC.Classes.Eq GI.Gtk.Enums.FontRendering
instance GHC.Classes.Eq GI.Gtk.Enums.GraphicsOffloadEnabled
instance GHC.Classes.Eq GI.Gtk.Enums.IconSize
instance GHC.Classes.Eq GI.Gtk.Enums.IconThemeError
instance GHC.Classes.Eq GI.Gtk.Enums.IconViewDropPosition
instance GHC.Classes.Eq GI.Gtk.Enums.ImageType
instance GHC.Classes.Eq GI.Gtk.Enums.InputPurpose
instance GHC.Classes.Eq GI.Gtk.Enums.InscriptionOverflow
instance GHC.Classes.Eq GI.Gtk.Enums.InterfaceColorScheme
instance GHC.Classes.Eq GI.Gtk.Enums.InterfaceContrast
instance GHC.Classes.Eq GI.Gtk.Enums.Justification
instance GHC.Classes.Eq GI.Gtk.Enums.LevelBarMode
instance GHC.Classes.Eq GI.Gtk.Enums.License
instance GHC.Classes.Eq GI.Gtk.Enums.ListTabBehavior
instance GHC.Classes.Eq GI.Gtk.Enums.MessageType
instance GHC.Classes.Eq GI.Gtk.Enums.MovementStep
instance GHC.Classes.Eq GI.Gtk.Enums.NaturalWrapMode
instance GHC.Classes.Eq GI.Gtk.Enums.NotebookTab
instance GHC.Classes.Eq GI.Gtk.Enums.NumberUpLayout
instance GHC.Classes.Eq GI.Gtk.Enums.Ordering
instance GHC.Classes.Eq GI.Gtk.Enums.Orientation
instance GHC.Classes.Eq GI.Gtk.Enums.Overflow
instance GHC.Classes.Eq GI.Gtk.Enums.PackType
instance GHC.Classes.Eq GI.Gtk.Enums.PadActionType
instance GHC.Classes.Eq GI.Gtk.Enums.PageOrientation
instance GHC.Classes.Eq GI.Gtk.Enums.PageSet
instance GHC.Classes.Eq GI.Gtk.Enums.PanDirection
instance GHC.Classes.Eq GI.Gtk.Enums.PolicyType
instance GHC.Classes.Eq GI.Gtk.Enums.PositionType
instance GHC.Classes.Eq GI.Gtk.Enums.PrintDuplex
instance GHC.Classes.Eq GI.Gtk.Enums.PrintError
instance GHC.Classes.Eq GI.Gtk.Enums.PrintOperationAction
instance GHC.Classes.Eq GI.Gtk.Enums.PrintOperationResult
instance GHC.Classes.Eq GI.Gtk.Enums.PrintPages
instance GHC.Classes.Eq GI.Gtk.Enums.PrintQuality
instance GHC.Classes.Eq GI.Gtk.Enums.PrintStatus
instance GHC.Classes.Eq GI.Gtk.Enums.PropagationLimit
instance GHC.Classes.Eq GI.Gtk.Enums.PropagationPhase
instance GHC.Classes.Eq GI.Gtk.Enums.RecentManagerError
instance GHC.Classes.Eq GI.Gtk.Enums.ReducedMotion
instance GHC.Classes.Eq GI.Gtk.Enums.ResponseType
instance GHC.Classes.Eq GI.Gtk.Enums.RevealerTransitionType
instance GHC.Classes.Eq GI.Gtk.Enums.ScrollStep
instance GHC.Classes.Eq GI.Gtk.Enums.ScrollType
instance GHC.Classes.Eq GI.Gtk.Enums.ScrollablePolicy
instance GHC.Classes.Eq GI.Gtk.Enums.SelectionMode
instance GHC.Classes.Eq GI.Gtk.Enums.SensitivityType
instance GHC.Classes.Eq GI.Gtk.Enums.ShortcutScope
instance GHC.Classes.Eq GI.Gtk.Enums.ShortcutType
instance GHC.Classes.Eq GI.Gtk.Enums.SizeGroupMode
instance GHC.Classes.Eq GI.Gtk.Enums.SizeRequestMode
instance GHC.Classes.Eq GI.Gtk.Enums.SortType
instance GHC.Classes.Eq GI.Gtk.Enums.SorterChange
instance GHC.Classes.Eq GI.Gtk.Enums.SorterOrder
instance GHC.Classes.Eq GI.Gtk.Enums.SpinButtonUpdatePolicy
instance GHC.Classes.Eq GI.Gtk.Enums.SpinType
instance GHC.Classes.Eq GI.Gtk.Enums.StackTransitionType
instance GHC.Classes.Eq GI.Gtk.Enums.StringFilterMatchMode
instance GHC.Classes.Eq GI.Gtk.Enums.SvgError
instance GHC.Classes.Eq GI.Gtk.Enums.SymbolicColor
instance GHC.Classes.Eq GI.Gtk.Enums.SystemSetting
instance GHC.Classes.Eq GI.Gtk.Enums.TextDirection
instance GHC.Classes.Eq GI.Gtk.Enums.TextExtendSelection
instance GHC.Classes.Eq GI.Gtk.Enums.TextViewLayer
instance GHC.Classes.Eq GI.Gtk.Enums.TextWindowType
instance GHC.Classes.Eq GI.Gtk.Enums.TreeViewColumnSizing
instance GHC.Classes.Eq GI.Gtk.Enums.TreeViewDropPosition
instance GHC.Classes.Eq GI.Gtk.Enums.TreeViewGridLines
instance GHC.Classes.Eq GI.Gtk.Enums.Unit
instance GHC.Classes.Eq GI.Gtk.Enums.WindowGravity
instance GHC.Classes.Eq GI.Gtk.Enums.WrapMode
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.BuilderError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.ConstraintVflParserError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.CssParserError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.DialogError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.FileChooserError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.IconThemeError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.PrintError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.RecentManagerError
instance Data.GI.Base.GError.GErrorClass GI.Gtk.Enums.SvgError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleAnnouncementPriority
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleAutocomplete
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleInvalidState
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessiblePlatformState
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleProperty
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleRelation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleRole
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleSort
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleState
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleTextContentChange
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleTextGranularity
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AccessibleTristate
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.Align
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ArrowType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.AssistantPageType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.BaselinePosition
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.BorderStyle
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.BuilderError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ButtonsType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.CellRendererAccelMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.CellRendererMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.Collation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ConstraintAttribute
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ConstraintRelation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ConstraintStrength
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ConstraintVflParserError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ContentFit
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.CornerType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.DeleteType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.DialogError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.DirectionType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.EditableProperties
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.EntryIconPosition
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.EventSequenceState
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.FileChooserAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.FileChooserError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.FilterChange
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.FilterMatch
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.FontLevel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.FontRendering
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.GraphicsOffloadEnabled
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.IconSize
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.IconThemeError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.IconViewDropPosition
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ImageType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.InputPurpose
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.InscriptionOverflow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.InterfaceColorScheme
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.InterfaceContrast
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.Justification
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.LevelBarMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.License
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ListTabBehavior
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.MessageType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.MovementStep
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.NaturalWrapMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.NotebookTab
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.NumberUpLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.Ordering
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.Orientation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.Overflow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PackType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PadActionType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PageOrientation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PageSet
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PanDirection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PolicyType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PositionType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PrintDuplex
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PrintError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PrintOperationAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PrintOperationResult
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PrintPages
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PrintQuality
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PrintStatus
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PropagationLimit
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.PropagationPhase
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.RecentManagerError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ReducedMotion
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ResponseType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.RevealerTransitionType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ScrollStep
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ScrollType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ScrollablePolicy
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SelectionMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SensitivityType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ShortcutScope
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.ShortcutType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SizeGroupMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SizeRequestMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SortType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SorterChange
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SorterOrder
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SpinButtonUpdatePolicy
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SpinType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.StackTransitionType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.StringFilterMatchMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SvgError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SymbolicColor
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.SystemSetting
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.TextDirection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.TextExtendSelection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.TextViewLayer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.TextWindowType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.TreeViewColumnSizing
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.TreeViewDropPosition
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.TreeViewGridLines
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.Unit
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.WindowGravity
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Enums.WrapMode
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleAnnouncementPriority
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleAutocomplete
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleInvalidState
instance GHC.Classes.Ord GI.Gtk.Enums.AccessiblePlatformState
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleProperty
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleRelation
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleRole
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleSort
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleState
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleTextContentChange
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleTextGranularity
instance GHC.Classes.Ord GI.Gtk.Enums.AccessibleTristate
instance GHC.Classes.Ord GI.Gtk.Enums.Align
instance GHC.Classes.Ord GI.Gtk.Enums.ArrowType
instance GHC.Classes.Ord GI.Gtk.Enums.AssistantPageType
instance GHC.Classes.Ord GI.Gtk.Enums.BaselinePosition
instance GHC.Classes.Ord GI.Gtk.Enums.BorderStyle
instance GHC.Classes.Ord GI.Gtk.Enums.BuilderError
instance GHC.Classes.Ord GI.Gtk.Enums.ButtonsType
instance GHC.Classes.Ord GI.Gtk.Enums.CellRendererAccelMode
instance GHC.Classes.Ord GI.Gtk.Enums.CellRendererMode
instance GHC.Classes.Ord GI.Gtk.Enums.Collation
instance GHC.Classes.Ord GI.Gtk.Enums.ConstraintAttribute
instance GHC.Classes.Ord GI.Gtk.Enums.ConstraintRelation
instance GHC.Classes.Ord GI.Gtk.Enums.ConstraintStrength
instance GHC.Classes.Ord GI.Gtk.Enums.ConstraintVflParserError
instance GHC.Classes.Ord GI.Gtk.Enums.ContentFit
instance GHC.Classes.Ord GI.Gtk.Enums.CornerType
instance GHC.Classes.Ord GI.Gtk.Enums.CssParserError
instance GHC.Classes.Ord GI.Gtk.Enums.CssParserWarning
instance GHC.Classes.Ord GI.Gtk.Enums.DeleteType
instance GHC.Classes.Ord GI.Gtk.Enums.DialogError
instance GHC.Classes.Ord GI.Gtk.Enums.DirectionType
instance GHC.Classes.Ord GI.Gtk.Enums.EditableProperties
instance GHC.Classes.Ord GI.Gtk.Enums.EntryIconPosition
instance GHC.Classes.Ord GI.Gtk.Enums.EventSequenceState
instance GHC.Classes.Ord GI.Gtk.Enums.FileChooserAction
instance GHC.Classes.Ord GI.Gtk.Enums.FileChooserError
instance GHC.Classes.Ord GI.Gtk.Enums.FilterChange
instance GHC.Classes.Ord GI.Gtk.Enums.FilterMatch
instance GHC.Classes.Ord GI.Gtk.Enums.FontLevel
instance GHC.Classes.Ord GI.Gtk.Enums.FontRendering
instance GHC.Classes.Ord GI.Gtk.Enums.GraphicsOffloadEnabled
instance GHC.Classes.Ord GI.Gtk.Enums.IconSize
instance GHC.Classes.Ord GI.Gtk.Enums.IconThemeError
instance GHC.Classes.Ord GI.Gtk.Enums.IconViewDropPosition
instance GHC.Classes.Ord GI.Gtk.Enums.ImageType
instance GHC.Classes.Ord GI.Gtk.Enums.InputPurpose
instance GHC.Classes.Ord GI.Gtk.Enums.InscriptionOverflow
instance GHC.Classes.Ord GI.Gtk.Enums.InterfaceColorScheme
instance GHC.Classes.Ord GI.Gtk.Enums.InterfaceContrast
instance GHC.Classes.Ord GI.Gtk.Enums.Justification
instance GHC.Classes.Ord GI.Gtk.Enums.LevelBarMode
instance GHC.Classes.Ord GI.Gtk.Enums.License
instance GHC.Classes.Ord GI.Gtk.Enums.ListTabBehavior
instance GHC.Classes.Ord GI.Gtk.Enums.MessageType
instance GHC.Classes.Ord GI.Gtk.Enums.MovementStep
instance GHC.Classes.Ord GI.Gtk.Enums.NaturalWrapMode
instance GHC.Classes.Ord GI.Gtk.Enums.NotebookTab
instance GHC.Classes.Ord GI.Gtk.Enums.NumberUpLayout
instance GHC.Classes.Ord GI.Gtk.Enums.Ordering
instance GHC.Classes.Ord GI.Gtk.Enums.Orientation
instance GHC.Classes.Ord GI.Gtk.Enums.Overflow
instance GHC.Classes.Ord GI.Gtk.Enums.PackType
instance GHC.Classes.Ord GI.Gtk.Enums.PadActionType
instance GHC.Classes.Ord GI.Gtk.Enums.PageOrientation
instance GHC.Classes.Ord GI.Gtk.Enums.PageSet
instance GHC.Classes.Ord GI.Gtk.Enums.PanDirection
instance GHC.Classes.Ord GI.Gtk.Enums.PolicyType
instance GHC.Classes.Ord GI.Gtk.Enums.PositionType
instance GHC.Classes.Ord GI.Gtk.Enums.PrintDuplex
instance GHC.Classes.Ord GI.Gtk.Enums.PrintError
instance GHC.Classes.Ord GI.Gtk.Enums.PrintOperationAction
instance GHC.Classes.Ord GI.Gtk.Enums.PrintOperationResult
instance GHC.Classes.Ord GI.Gtk.Enums.PrintPages
instance GHC.Classes.Ord GI.Gtk.Enums.PrintQuality
instance GHC.Classes.Ord GI.Gtk.Enums.PrintStatus
instance GHC.Classes.Ord GI.Gtk.Enums.PropagationLimit
instance GHC.Classes.Ord GI.Gtk.Enums.PropagationPhase
instance GHC.Classes.Ord GI.Gtk.Enums.RecentManagerError
instance GHC.Classes.Ord GI.Gtk.Enums.ReducedMotion
instance GHC.Classes.Ord GI.Gtk.Enums.ResponseType
instance GHC.Classes.Ord GI.Gtk.Enums.RevealerTransitionType
instance GHC.Classes.Ord GI.Gtk.Enums.ScrollStep
instance GHC.Classes.Ord GI.Gtk.Enums.ScrollType
instance GHC.Classes.Ord GI.Gtk.Enums.ScrollablePolicy
instance GHC.Classes.Ord GI.Gtk.Enums.SelectionMode
instance GHC.Classes.Ord GI.Gtk.Enums.SensitivityType
instance GHC.Classes.Ord GI.Gtk.Enums.ShortcutScope
instance GHC.Classes.Ord GI.Gtk.Enums.ShortcutType
instance GHC.Classes.Ord GI.Gtk.Enums.SizeGroupMode
instance GHC.Classes.Ord GI.Gtk.Enums.SizeRequestMode
instance GHC.Classes.Ord GI.Gtk.Enums.SortType
instance GHC.Classes.Ord GI.Gtk.Enums.SorterChange
instance GHC.Classes.Ord GI.Gtk.Enums.SorterOrder
instance GHC.Classes.Ord GI.Gtk.Enums.SpinButtonUpdatePolicy
instance GHC.Classes.Ord GI.Gtk.Enums.SpinType
instance GHC.Classes.Ord GI.Gtk.Enums.StackTransitionType
instance GHC.Classes.Ord GI.Gtk.Enums.StringFilterMatchMode
instance GHC.Classes.Ord GI.Gtk.Enums.SvgError
instance GHC.Classes.Ord GI.Gtk.Enums.SymbolicColor
instance GHC.Classes.Ord GI.Gtk.Enums.SystemSetting
instance GHC.Classes.Ord GI.Gtk.Enums.TextDirection
instance GHC.Classes.Ord GI.Gtk.Enums.TextExtendSelection
instance GHC.Classes.Ord GI.Gtk.Enums.TextViewLayer
instance GHC.Classes.Ord GI.Gtk.Enums.TextWindowType
instance GHC.Classes.Ord GI.Gtk.Enums.TreeViewColumnSizing
instance GHC.Classes.Ord GI.Gtk.Enums.TreeViewDropPosition
instance GHC.Classes.Ord GI.Gtk.Enums.TreeViewGridLines
instance GHC.Classes.Ord GI.Gtk.Enums.Unit
instance GHC.Classes.Ord GI.Gtk.Enums.WindowGravity
instance GHC.Classes.Ord GI.Gtk.Enums.WrapMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleAnnouncementPriority
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleAutocomplete
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleInvalidState
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessiblePlatformState
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleProperty
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleRelation
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleRole
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleSort
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleState
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleTextContentChange
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleTextGranularity
instance GHC.Internal.Show.Show GI.Gtk.Enums.AccessibleTristate
instance GHC.Internal.Show.Show GI.Gtk.Enums.Align
instance GHC.Internal.Show.Show GI.Gtk.Enums.ArrowType
instance GHC.Internal.Show.Show GI.Gtk.Enums.AssistantPageType
instance GHC.Internal.Show.Show GI.Gtk.Enums.BaselinePosition
instance GHC.Internal.Show.Show GI.Gtk.Enums.BorderStyle
instance GHC.Internal.Show.Show GI.Gtk.Enums.BuilderError
instance GHC.Internal.Show.Show GI.Gtk.Enums.ButtonsType
instance GHC.Internal.Show.Show GI.Gtk.Enums.CellRendererAccelMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.CellRendererMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.Collation
instance GHC.Internal.Show.Show GI.Gtk.Enums.ConstraintAttribute
instance GHC.Internal.Show.Show GI.Gtk.Enums.ConstraintRelation
instance GHC.Internal.Show.Show GI.Gtk.Enums.ConstraintStrength
instance GHC.Internal.Show.Show GI.Gtk.Enums.ConstraintVflParserError
instance GHC.Internal.Show.Show GI.Gtk.Enums.ContentFit
instance GHC.Internal.Show.Show GI.Gtk.Enums.CornerType
instance GHC.Internal.Show.Show GI.Gtk.Enums.CssParserError
instance GHC.Internal.Show.Show GI.Gtk.Enums.CssParserWarning
instance GHC.Internal.Show.Show GI.Gtk.Enums.DeleteType
instance GHC.Internal.Show.Show GI.Gtk.Enums.DialogError
instance GHC.Internal.Show.Show GI.Gtk.Enums.DirectionType
instance GHC.Internal.Show.Show GI.Gtk.Enums.EditableProperties
instance GHC.Internal.Show.Show GI.Gtk.Enums.EntryIconPosition
instance GHC.Internal.Show.Show GI.Gtk.Enums.EventSequenceState
instance GHC.Internal.Show.Show GI.Gtk.Enums.FileChooserAction
instance GHC.Internal.Show.Show GI.Gtk.Enums.FileChooserError
instance GHC.Internal.Show.Show GI.Gtk.Enums.FilterChange
instance GHC.Internal.Show.Show GI.Gtk.Enums.FilterMatch
instance GHC.Internal.Show.Show GI.Gtk.Enums.FontLevel
instance GHC.Internal.Show.Show GI.Gtk.Enums.FontRendering
instance GHC.Internal.Show.Show GI.Gtk.Enums.GraphicsOffloadEnabled
instance GHC.Internal.Show.Show GI.Gtk.Enums.IconSize
instance GHC.Internal.Show.Show GI.Gtk.Enums.IconThemeError
instance GHC.Internal.Show.Show GI.Gtk.Enums.IconViewDropPosition
instance GHC.Internal.Show.Show GI.Gtk.Enums.ImageType
instance GHC.Internal.Show.Show GI.Gtk.Enums.InputPurpose
instance GHC.Internal.Show.Show GI.Gtk.Enums.InscriptionOverflow
instance GHC.Internal.Show.Show GI.Gtk.Enums.InterfaceColorScheme
instance GHC.Internal.Show.Show GI.Gtk.Enums.InterfaceContrast
instance GHC.Internal.Show.Show GI.Gtk.Enums.Justification
instance GHC.Internal.Show.Show GI.Gtk.Enums.LevelBarMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.License
instance GHC.Internal.Show.Show GI.Gtk.Enums.ListTabBehavior
instance GHC.Internal.Show.Show GI.Gtk.Enums.MessageType
instance GHC.Internal.Show.Show GI.Gtk.Enums.MovementStep
instance GHC.Internal.Show.Show GI.Gtk.Enums.NaturalWrapMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.NotebookTab
instance GHC.Internal.Show.Show GI.Gtk.Enums.NumberUpLayout
instance GHC.Internal.Show.Show GI.Gtk.Enums.Ordering
instance GHC.Internal.Show.Show GI.Gtk.Enums.Orientation
instance GHC.Internal.Show.Show GI.Gtk.Enums.Overflow
instance GHC.Internal.Show.Show GI.Gtk.Enums.PackType
instance GHC.Internal.Show.Show GI.Gtk.Enums.PadActionType
instance GHC.Internal.Show.Show GI.Gtk.Enums.PageOrientation
instance GHC.Internal.Show.Show GI.Gtk.Enums.PageSet
instance GHC.Internal.Show.Show GI.Gtk.Enums.PanDirection
instance GHC.Internal.Show.Show GI.Gtk.Enums.PolicyType
instance GHC.Internal.Show.Show GI.Gtk.Enums.PositionType
instance GHC.Internal.Show.Show GI.Gtk.Enums.PrintDuplex
instance GHC.Internal.Show.Show GI.Gtk.Enums.PrintError
instance GHC.Internal.Show.Show GI.Gtk.Enums.PrintOperationAction
instance GHC.Internal.Show.Show GI.Gtk.Enums.PrintOperationResult
instance GHC.Internal.Show.Show GI.Gtk.Enums.PrintPages
instance GHC.Internal.Show.Show GI.Gtk.Enums.PrintQuality
instance GHC.Internal.Show.Show GI.Gtk.Enums.PrintStatus
instance GHC.Internal.Show.Show GI.Gtk.Enums.PropagationLimit
instance GHC.Internal.Show.Show GI.Gtk.Enums.PropagationPhase
instance GHC.Internal.Show.Show GI.Gtk.Enums.RecentManagerError
instance GHC.Internal.Show.Show GI.Gtk.Enums.ReducedMotion
instance GHC.Internal.Show.Show GI.Gtk.Enums.ResponseType
instance GHC.Internal.Show.Show GI.Gtk.Enums.RevealerTransitionType
instance GHC.Internal.Show.Show GI.Gtk.Enums.ScrollStep
instance GHC.Internal.Show.Show GI.Gtk.Enums.ScrollType
instance GHC.Internal.Show.Show GI.Gtk.Enums.ScrollablePolicy
instance GHC.Internal.Show.Show GI.Gtk.Enums.SelectionMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.SensitivityType
instance GHC.Internal.Show.Show GI.Gtk.Enums.ShortcutScope
instance GHC.Internal.Show.Show GI.Gtk.Enums.ShortcutType
instance GHC.Internal.Show.Show GI.Gtk.Enums.SizeGroupMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.SizeRequestMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.SortType
instance GHC.Internal.Show.Show GI.Gtk.Enums.SorterChange
instance GHC.Internal.Show.Show GI.Gtk.Enums.SorterOrder
instance GHC.Internal.Show.Show GI.Gtk.Enums.SpinButtonUpdatePolicy
instance GHC.Internal.Show.Show GI.Gtk.Enums.SpinType
instance GHC.Internal.Show.Show GI.Gtk.Enums.StackTransitionType
instance GHC.Internal.Show.Show GI.Gtk.Enums.StringFilterMatchMode
instance GHC.Internal.Show.Show GI.Gtk.Enums.SvgError
instance GHC.Internal.Show.Show GI.Gtk.Enums.SymbolicColor
instance GHC.Internal.Show.Show GI.Gtk.Enums.SystemSetting
instance GHC.Internal.Show.Show GI.Gtk.Enums.TextDirection
instance GHC.Internal.Show.Show GI.Gtk.Enums.TextExtendSelection
instance GHC.Internal.Show.Show GI.Gtk.Enums.TextViewLayer
instance GHC.Internal.Show.Show GI.Gtk.Enums.TextWindowType
instance GHC.Internal.Show.Show GI.Gtk.Enums.TreeViewColumnSizing
instance GHC.Internal.Show.Show GI.Gtk.Enums.TreeViewDropPosition
instance GHC.Internal.Show.Show GI.Gtk.Enums.TreeViewGridLines
instance GHC.Internal.Show.Show GI.Gtk.Enums.Unit
instance GHC.Internal.Show.Show GI.Gtk.Enums.WindowGravity
instance GHC.Internal.Show.Show GI.Gtk.Enums.WrapMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleAnnouncementPriority
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleAutocomplete
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleInvalidState
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessiblePlatformState
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleProperty
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleRelation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleRole
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleSort
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleState
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleTextContentChange
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleTextGranularity
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AccessibleTristate
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.Align
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ArrowType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.AssistantPageType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.BaselinePosition
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.BorderStyle
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.BuilderError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ButtonsType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.CellRendererAccelMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.CellRendererMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.Collation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ConstraintAttribute
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ConstraintRelation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ConstraintStrength
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ConstraintVflParserError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ContentFit
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.CornerType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.DeleteType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.DialogError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.DirectionType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.EditableProperties
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.EntryIconPosition
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.EventSequenceState
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.FileChooserAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.FileChooserError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.FilterChange
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.FilterMatch
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.FontLevel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.FontRendering
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.GraphicsOffloadEnabled
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.IconSize
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.IconThemeError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.IconViewDropPosition
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ImageType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.InputPurpose
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.InscriptionOverflow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.InterfaceColorScheme
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.InterfaceContrast
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.Justification
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.LevelBarMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.License
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ListTabBehavior
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.MessageType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.MovementStep
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.NaturalWrapMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.NotebookTab
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.NumberUpLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.Ordering
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.Orientation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.Overflow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PackType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PadActionType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PageOrientation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PageSet
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PanDirection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PolicyType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PositionType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PrintDuplex
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PrintError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PrintOperationAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PrintOperationResult
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PrintPages
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PrintQuality
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PrintStatus
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PropagationLimit
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.PropagationPhase
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.RecentManagerError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ReducedMotion
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ResponseType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.RevealerTransitionType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ScrollStep
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ScrollType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ScrollablePolicy
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SelectionMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SensitivityType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ShortcutScope
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.ShortcutType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SizeGroupMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SizeRequestMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SortType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SorterChange
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SorterOrder
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SpinButtonUpdatePolicy
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SpinType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.StackTransitionType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.StringFilterMatchMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SvgError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SymbolicColor
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.SystemSetting
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.TextDirection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.TextExtendSelection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.TextViewLayer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.TextWindowType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.TreeViewColumnSizing
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.TreeViewDropPosition
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.TreeViewGridLines
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.Unit
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.WindowGravity
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Enums.WrapMode


module GI.Gtk.Flags

-- | Types of user actions that may be blocked by <tt>GtkApplication</tt>.
--   
--   See <a>applicationInhibit</a>.
data ApplicationInhibitFlags

-- | Inhibit ending the user session by logging out or by shutting down the
--   computer
ApplicationInhibitFlagsLogout :: ApplicationInhibitFlags

-- | Inhibit user switching
ApplicationInhibitFlagsSwitch :: ApplicationInhibitFlags

-- | Inhibit suspending the session or computer
ApplicationInhibitFlagsSuspend :: ApplicationInhibitFlags

-- | Inhibit the session being marked as idle (and possibly locked)
ApplicationInhibitFlagsIdle :: ApplicationInhibitFlags

-- | Catch-all for unknown values
AnotherApplicationInhibitFlags :: Int -> ApplicationInhibitFlags

-- | The list of flags that can be passed to <a>builderCreateClosure</a>.
--   
--   New values may be added in the future for new features, so external
--   implementations of <a>BuilderScope</a> should test the flags for
--   unknown values and raise a <a>BuilderErrorInvalidAttribute</a> error
--   when they encounter one.
data BuilderClosureFlags

-- | The closure should be created swapped. See
--   <tt><i>g_cclosure_new_swap()</i></tt> for details.
BuilderClosureFlagsSwapped :: BuilderClosureFlags

-- | Catch-all for unknown values
AnotherBuilderClosureFlags :: Int -> BuilderClosureFlags

-- | Tells how a cell is to be rendered.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data CellRendererState

-- | The cell is currently selected, and probably has a selection colored
--   background to render to.
CellRendererStateSelected :: CellRendererState

-- | The mouse is hovering over the cell.
CellRendererStatePrelit :: CellRendererState

-- | The cell is drawn in an insensitive manner
CellRendererStateInsensitive :: CellRendererState

-- | The cell is in a sorted row
CellRendererStateSorted :: CellRendererState

-- | The cell is in the focus row.
CellRendererStateFocused :: CellRendererState

-- | The cell is in a row that can be expanded
CellRendererStateExpandable :: CellRendererState

-- | The cell is in a row that is expanded
CellRendererStateExpanded :: CellRendererState

-- | Catch-all for unknown values
AnotherCellRendererState :: Int -> CellRendererState

-- | Flags to use with <a>setDebugFlags</a>.
--   
--   Settings these flags causes GTK to print out different types of
--   debugging information. Some of these flags are only available when GTK
--   has been configured with <tt>-Ddebug=true</tt>.
data DebugFlags

-- | Information about GtkTextView
DebugFlagsText :: DebugFlags

-- | Information about GtkTreeView
DebugFlagsTree :: DebugFlags

-- | Information about keyboard shortcuts
DebugFlagsKeybindings :: DebugFlags

-- | Information about modules and extensions
DebugFlagsModules :: DebugFlags

-- | Information about size allocation
DebugFlagsGeometry :: DebugFlags

-- | Information about icon themes
DebugFlagsIcontheme :: DebugFlags

-- | Information about printing
DebugFlagsPrinting :: DebugFlags

-- | Trace GtkBuilder operation
DebugFlagsBuilderTrace :: DebugFlags

-- | Information about size requests
DebugFlagsSizeRequest :: DebugFlags

-- | Disable the style property cache
DebugFlagsNoCssCache :: DebugFlags

-- | Open the GTK inspector
DebugFlagsInteractive :: DebugFlags

-- | Show touch UI elements for pointer events.
--   
--   <i>Since: 4.20</i>
DebugFlagsTouchscreen :: DebugFlags

-- | Information about actions and menu models
DebugFlagsActions :: DebugFlags

-- | Information from layout managers
DebugFlagsLayout :: DebugFlags

-- | Include debug render nodes in the generated snapshots
DebugFlagsSnapshot :: DebugFlags

-- | Information from the constraints solver
DebugFlagsConstraints :: DebugFlags

-- | Log unused GtkBuilder objects
DebugFlagsBuilderObjects :: DebugFlags

-- | Information about accessibility state changes
DebugFlagsA11y :: DebugFlags

-- | Information about icon fallback.
--   
--   <i>Since: 4.2</i>
DebugFlagsIconfallback :: DebugFlags

-- | Inverts the default text-direction.
--   
--   <i>Since: 4.8</i>
DebugFlagsInvertTextDir :: DebugFlags

-- | Information about deprecated CSS features.
--   
--   <i>Since: 4.16</i>
DebugFlagsCss :: DebugFlags

-- | Information about deprecated GtkBuilder features.
--   
--   <i>Since: 4.18</i>
DebugFlagsBuilder :: DebugFlags

-- | Information about session saving.
--   
--   <i>Since: 4.22</i>
DebugFlagsSession :: DebugFlags

-- | Catch-all for unknown values
AnotherDebugFlags :: Int -> DebugFlags

-- | Flags used to influence dialog construction.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data DialogFlags

-- | Make the constructed dialog modal
DialogFlagsModal :: DialogFlags

-- | Destroy the dialog when its parent is destroyed
DialogFlagsDestroyWithParent :: DialogFlags

-- | Create dialog with actions in header bar instead of action area
DialogFlagsUseHeaderBar :: DialogFlags

-- | Catch-all for unknown values
AnotherDialogFlags :: Int -> DialogFlags

-- | Describes the behavior of a <tt>GtkEventControllerScroll</tt>.
data EventControllerScrollFlags

-- | Don't emit scroll.
EventControllerScrollFlagsNone :: EventControllerScrollFlags

-- | Emit scroll with vertical deltas.
EventControllerScrollFlagsVertical :: EventControllerScrollFlags

-- | Emit scroll with horizontal deltas.
EventControllerScrollFlagsHorizontal :: EventControllerScrollFlags

-- | Only emit deltas that are multiples of 1.
EventControllerScrollFlagsDiscrete :: EventControllerScrollFlags

-- | Emit <a>decelerate</a> after continuous scroll finishes.
EventControllerScrollFlagsKinetic :: EventControllerScrollFlags

-- | A <a>EventControllerScrollFlags</a> value to prefer physical direction
--   over logical direction (i.e. oblivious to natural scroll).
--   
--   <i>Since: 4.20</i>
EventControllerScrollFlagsPhysicalDirection :: EventControllerScrollFlags

-- | Emit scroll on both axes.
EventControllerScrollFlagsBothAxes :: EventControllerScrollFlags

-- | Catch-all for unknown values
AnotherEventControllerScrollFlags :: Int -> EventControllerScrollFlags

-- | Specifies the granularity of font selection that is desired in a
--   <tt>GtkFontChooser</tt>.
--   
--   This enumeration may be extended in the future; applications should
--   ignore unknown values.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
data FontChooserLevel

-- | Allow selecting a font family
FontChooserLevelFamily :: FontChooserLevel

-- | Allow selecting a specific font face
FontChooserLevelStyle :: FontChooserLevel

-- | Allow selecting a specific font size
FontChooserLevelSize :: FontChooserLevel

-- | Allow changing OpenType font variation axes
FontChooserLevelVariations :: FontChooserLevel

-- | Allow selecting specific OpenType font features
FontChooserLevelFeatures :: FontChooserLevel

-- | Catch-all for unknown values
AnotherFontChooserLevel :: Int -> FontChooserLevel

-- | Used to specify options for <a>iconThemeLookupIcon</a>.
data IconLookupFlags

-- | Perform a regular lookup.
--   
--   <i>Since: 4.18</i>
IconLookupFlagsNone :: IconLookupFlags

-- | Try to always load regular icons, even when symbolic icon names are
--   given
IconLookupFlagsForceRegular :: IconLookupFlags

-- | Try to always load symbolic icons, even when regular icon names are
--   given
IconLookupFlagsForceSymbolic :: IconLookupFlags

-- | Starts loading the texture in the background so it is ready when later
--   needed.
IconLookupFlagsPreload :: IconLookupFlags

-- | Catch-all for unknown values
AnotherIconLookupFlags :: Int -> IconLookupFlags

-- | Describes hints that might be taken into account by input methods or
--   applications.
--   
--   Note that input methods may already tailor their behaviour according
--   to the [enum<i><tt>inputPurpose</tt></i>] of the entry.
--   
--   Some common sense is expected when using these flags - mixing
--   <a>InputHintsLowercase</a> with any of the uppercase hints makes no
--   sense.
--   
--   This enumeration may be extended in the future; input methods should
--   ignore unknown values.
data InputHints

-- | No special behaviour suggested
InputHintsNone :: InputHints

-- | Suggest checking for typos
InputHintsSpellcheck :: InputHints

-- | Suggest not checking for typos
InputHintsNoSpellcheck :: InputHints

-- | Suggest word completion
InputHintsWordCompletion :: InputHints

-- | Suggest to convert all text to lowercase
InputHintsLowercase :: InputHints

-- | Suggest to capitalize all text
InputHintsUppercaseChars :: InputHints

-- | Suggest to capitalize the first character of each word
InputHintsUppercaseWords :: InputHints

-- | Suggest to capitalize the first word of each sentence
InputHintsUppercaseSentences :: InputHints

-- | Suggest to not show an onscreen keyboard (e.g for a calculator that
--   already has all the keys).
InputHintsInhibitOsk :: InputHints

-- | The text is vertical
InputHintsVerticalWriting :: InputHints

-- | Suggest offering Emoji support
InputHintsEmoji :: InputHints

-- | Suggest not offering Emoji support
InputHintsNoEmoji :: InputHints

-- | Request that the input method should not update personalized data
--   (like typing history)
InputHintsPrivate :: InputHints

-- | Catch-all for unknown values
AnotherInputHints :: Int -> InputHints

-- | List of actions to perform when scrolling to items in a list widget.
--   
--   <i>Since: 4.12</i>
data ListScrollFlags

-- | Don't do anything extra
ListScrollFlagsNone :: ListScrollFlags

-- | Focus the target item
ListScrollFlagsFocus :: ListScrollFlags

-- | Select the target item and unselect all other items.
ListScrollFlagsSelect :: ListScrollFlags

-- | Catch-all for unknown values
AnotherListScrollFlags :: Int -> ListScrollFlags

-- | Flags that influence the behavior of
--   [method<i><tt>widget</tt></i>.pick].
data PickFlags

-- | The default behavior, include widgets that are receiving events
PickFlagsDefault :: PickFlags

-- | Include widgets that are insensitive
PickFlagsInsensitive :: PickFlags

-- | Include widgets that are marked as non-targetable. See
--   [property<i><tt>widget</tt></i>:can-target]
PickFlagsNonTargetable :: PickFlags

-- | Catch-all for unknown values
AnotherPickFlags :: Int -> PickFlags

-- | Flags that affect how <a>PopoverMenu</a> widgets built from a
--   <a>MenuModel</a> are created and displayed.
data PopoverMenuFlags

-- | Submenus are presented as sliding submenus that replace the main menu.
--   
--   <i>Since: 4.14</i>
PopoverMenuFlagsSliding :: PopoverMenuFlags

-- | Submenus are presented as traditional, nested popovers.
PopoverMenuFlagsNested :: PopoverMenuFlags

-- | Catch-all for unknown values
AnotherPopoverMenuFlags :: Int -> PopoverMenuFlags

-- | Specifies which features the print dialog should offer.
--   
--   If neither <a>PrintCapabilitiesGeneratePdf</a> nor
--   <a>PrintCapabilitiesGeneratePs</a> is specified, GTK assumes that all
--   formats are supported.
data PrintCapabilities

-- | Print dialog will offer printing even/odd pages.
PrintCapabilitiesPageSet :: PrintCapabilities

-- | Print dialog will allow to print multiple copies.
PrintCapabilitiesCopies :: PrintCapabilities

-- | Print dialog will allow to collate multiple copies.
PrintCapabilitiesCollate :: PrintCapabilities

-- | Print dialog will allow to print pages in reverse order.
PrintCapabilitiesReverse :: PrintCapabilities

-- | Print dialog will allow to scale the output.
PrintCapabilitiesScale :: PrintCapabilities

-- | The program will send the document to the printer in PDF format
PrintCapabilitiesGeneratePdf :: PrintCapabilities

-- | The program will send the document to the printer in Postscript format
PrintCapabilitiesGeneratePs :: PrintCapabilities

-- | Print dialog will offer a preview
PrintCapabilitiesPreview :: PrintCapabilities

-- | Print dialog will offer printing multiple pages per sheet
PrintCapabilitiesNumberUp :: PrintCapabilities

-- | Print dialog will allow to rearrange pages when printing multiple
--   pages per sheet
PrintCapabilitiesNumberUpLayout :: PrintCapabilities

-- | Catch-all for unknown values
AnotherPrintCapabilities :: Int -> PrintCapabilities

-- | Flags that can be passed to action activation.
--   
--   More flags may be added in the future.
data ShortcutActionFlags

-- | The action is the only action that can be activated. If this flag is
--   not set, a future activation may select a different action.
ShortcutActionFlagsExclusive :: ShortcutActionFlags

-- | Catch-all for unknown values
AnotherShortcutActionFlags :: Int -> ShortcutActionFlags

-- | Describes a widget state.
--   
--   Widget states are used to match the widget against CSS pseudo-classes.
--   Note that GTK extends the regular CSS classes and sometimes uses
--   different names.
data StateFlags

-- | State during normal operation
StateFlagsNormal :: StateFlags

-- | Widget is active
StateFlagsActive :: StateFlags

-- | Widget has a mouse pointer over it
StateFlagsPrelight :: StateFlags

-- | Widget is selected
StateFlagsSelected :: StateFlags

-- | Widget is insensitive
StateFlagsInsensitive :: StateFlags

-- | Widget is inconsistent
StateFlagsInconsistent :: StateFlags

-- | Widget has the keyboard focus
StateFlagsFocused :: StateFlags

-- | Widget is in a background toplevel window
StateFlagsBackdrop :: StateFlags

-- | Widget is in left-to-right text direction
StateFlagsDirLtr :: StateFlags

-- | Widget is in right-to-left text direction
StateFlagsDirRtl :: StateFlags

-- | Widget is a link
StateFlagsLink :: StateFlags

-- | The location the widget points to has already been visited
StateFlagsVisited :: StateFlags

-- | Widget is checked
StateFlagsChecked :: StateFlags

-- | Widget is highlighted as a drop target for DND
StateFlagsDropActive :: StateFlags

-- | Widget has the visible focus
StateFlagsFocusVisible :: StateFlags

-- | Widget contains the keyboard focus
StateFlagsFocusWithin :: StateFlags

-- | Catch-all for unknown values
AnotherStateFlags :: Int -> StateFlags

-- | Flags that modify the behavior of <a>styleContextToString</a>.
--   
--   New values may be added to this enumeration.
data StyleContextPrintFlags

-- | Default value.
StyleContextPrintFlagsNone :: StyleContextPrintFlags

-- | Print the entire tree of CSS nodes starting at the style context's
--   node
StyleContextPrintFlagsRecurse :: StyleContextPrintFlags

-- | Show the values of the CSS properties for each node
StyleContextPrintFlagsShowStyle :: StyleContextPrintFlags

-- | Show information about what changes affect the styles
StyleContextPrintFlagsShowChange :: StyleContextPrintFlags

-- | Catch-all for unknown values
AnotherStyleContextPrintFlags :: Int -> StyleContextPrintFlags

-- | Features of the SVG renderer that can be enabled or disabled.
--   
--   By default, all features except <tt>GTK_SVG_TRADITIONAL_SYMBOLIC</tt>
--   are enabled.
--   
--   New values may be added in the future.
--   
--   <i>Since: 4.22</i>
data SvgFeatures

-- | Whether to run animations. If disabled, state changes are applied
--   without transitions
SvgFeaturesAnimations :: SvgFeatures

-- | Whether to use system resources, such as fonts. If disabled, only
--   embedded fonts are used
SvgFeaturesSystemResources :: SvgFeatures

-- | Whether to load external resources, such as images. If disabled, only
--   embedded images are loaded
SvgFeaturesExternalResources :: SvgFeatures

-- | Whether to allow gpa extensions, such as states and transitions
SvgFeaturesExtensions :: SvgFeatures

-- | This feature is meant for compatibility with old symbolic icons. If
--   this is enabled, fill and stroke attributes are ignored. The used
--   colors are derived from symbolic style classes if present, and the
--   default fill color is the symbolic foreground color.
SvgFeaturesTraditionalSymbolic :: SvgFeatures

-- | Catch-all for unknown values
AnotherSvgFeatures :: Int -> SvgFeatures

-- | Values for [callback<i><tt>gtk</tt></i>.TextBufferCommitNotify] to
--   denote the point of the notification.
--   
--   <i>Since: 4.16</i>
data TextBufferNotifyFlags

-- | Be notified before text is inserted into the underlying buffer.
TextBufferNotifyFlagsBeforeInsert :: TextBufferNotifyFlags

-- | Be notified after text has been inserted into the underlying buffer.
TextBufferNotifyFlagsAfterInsert :: TextBufferNotifyFlags

-- | Be notified before text is deleted from the underlying buffer.
TextBufferNotifyFlagsBeforeDelete :: TextBufferNotifyFlags

-- | Be notified after text has been deleted from the underlying buffer.
TextBufferNotifyFlagsAfterDelete :: TextBufferNotifyFlags

-- | Catch-all for unknown values
AnotherTextBufferNotifyFlags :: Int -> TextBufferNotifyFlags

-- | Flags affecting how a search is done.
--   
--   If neither <tt>GTK_TEXT_SEARCH_VISIBLE_ONLY</tt> nor
--   <tt>GTK_TEXT_SEARCH_TEXT_ONLY</tt> are enabled, the match must be
--   exact; the special 0xFFFC character will match embedded paintables or
--   child widgets.
data TextSearchFlags

-- | Search only visible data. A search match may have invisible text
--   interspersed.
TextSearchFlagsVisibleOnly :: TextSearchFlags

-- | Search only text. A match may have paintables or child widgets mixed
--   inside the matched range.
TextSearchFlagsTextOnly :: TextSearchFlags

-- | The text will be matched regardless of what case it is in.
TextSearchFlagsCaseInsensitive :: TextSearchFlags

-- | Catch-all for unknown values
AnotherTextSearchFlags :: Int -> TextSearchFlags

-- | These flags indicate various properties of a <tt>GtkTreeModel</tt>.
--   
--   They are returned by <a>treeModelGetFlags</a>, and must be static for
--   the lifetime of the object. A more complete description of
--   <a>TreeModelFlagsItersPersist</a> can be found in the overview of this
--   section.

-- | <i>Deprecated: (Since version 4.10)There is no replacement</i>
data TreeModelFlags

-- | iterators survive all signals emitted by the tree
TreeModelFlagsItersPersist :: TreeModelFlags

-- | the model is a list only, and never has children
TreeModelFlagsListOnly :: TreeModelFlags

-- | Catch-all for unknown values
AnotherTreeModelFlags :: Int -> TreeModelFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.ApplicationInhibitFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.BuilderClosureFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.CellRendererState
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.DebugFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.DialogFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.EventControllerScrollFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.FontChooserLevel
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.IconLookupFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.InputHints
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.ListScrollFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.PickFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.PopoverMenuFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.PrintCapabilities
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.ShortcutActionFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.StateFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.StyleContextPrintFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.SvgFeatures
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.TextBufferNotifyFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.TextSearchFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gtk.Flags.TreeModelFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.ApplicationInhibitFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.BuilderClosureFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.CellRendererState
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.DebugFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.DialogFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.EventControllerScrollFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.FontChooserLevel
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.IconLookupFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.InputHints
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.ListScrollFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.PickFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.PopoverMenuFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.PrintCapabilities
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.ShortcutActionFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.StateFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.StyleContextPrintFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.SvgFeatures
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.TextBufferNotifyFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.TextSearchFlags
instance GHC.Internal.Enum.Enum GI.Gtk.Flags.TreeModelFlags
instance GHC.Classes.Eq GI.Gtk.Flags.ApplicationInhibitFlags
instance GHC.Classes.Eq GI.Gtk.Flags.BuilderClosureFlags
instance GHC.Classes.Eq GI.Gtk.Flags.CellRendererState
instance GHC.Classes.Eq GI.Gtk.Flags.DebugFlags
instance GHC.Classes.Eq GI.Gtk.Flags.DialogFlags
instance GHC.Classes.Eq GI.Gtk.Flags.EventControllerScrollFlags
instance GHC.Classes.Eq GI.Gtk.Flags.FontChooserLevel
instance GHC.Classes.Eq GI.Gtk.Flags.IconLookupFlags
instance GHC.Classes.Eq GI.Gtk.Flags.InputHints
instance GHC.Classes.Eq GI.Gtk.Flags.ListScrollFlags
instance GHC.Classes.Eq GI.Gtk.Flags.PickFlags
instance GHC.Classes.Eq GI.Gtk.Flags.PopoverMenuFlags
instance GHC.Classes.Eq GI.Gtk.Flags.PrintCapabilities
instance GHC.Classes.Eq GI.Gtk.Flags.ShortcutActionFlags
instance GHC.Classes.Eq GI.Gtk.Flags.StateFlags
instance GHC.Classes.Eq GI.Gtk.Flags.StyleContextPrintFlags
instance GHC.Classes.Eq GI.Gtk.Flags.SvgFeatures
instance GHC.Classes.Eq GI.Gtk.Flags.TextBufferNotifyFlags
instance GHC.Classes.Eq GI.Gtk.Flags.TextSearchFlags
instance GHC.Classes.Eq GI.Gtk.Flags.TreeModelFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.ApplicationInhibitFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.BuilderClosureFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.CellRendererState
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.DebugFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.DialogFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.EventControllerScrollFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.FontChooserLevel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.IconLookupFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.InputHints
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.ListScrollFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.PickFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.PopoverMenuFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.PrintCapabilities
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.ShortcutActionFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.StateFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.StyleContextPrintFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.SvgFeatures
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.TextBufferNotifyFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.TextSearchFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Flags.TreeModelFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.ApplicationInhibitFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.BuilderClosureFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.CellRendererState
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.DebugFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.DialogFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.EventControllerScrollFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.FontChooserLevel
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.IconLookupFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.InputHints
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.ListScrollFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.PickFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.PopoverMenuFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.PrintCapabilities
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.ShortcutActionFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.StateFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.StyleContextPrintFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.SvgFeatures
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.TextBufferNotifyFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.TextSearchFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gtk.Flags.TreeModelFlags
instance GHC.Classes.Ord GI.Gtk.Flags.ApplicationInhibitFlags
instance GHC.Classes.Ord GI.Gtk.Flags.BuilderClosureFlags
instance GHC.Classes.Ord GI.Gtk.Flags.CellRendererState
instance GHC.Classes.Ord GI.Gtk.Flags.DebugFlags
instance GHC.Classes.Ord GI.Gtk.Flags.DialogFlags
instance GHC.Classes.Ord GI.Gtk.Flags.EventControllerScrollFlags
instance GHC.Classes.Ord GI.Gtk.Flags.FontChooserLevel
instance GHC.Classes.Ord GI.Gtk.Flags.IconLookupFlags
instance GHC.Classes.Ord GI.Gtk.Flags.InputHints
instance GHC.Classes.Ord GI.Gtk.Flags.ListScrollFlags
instance GHC.Classes.Ord GI.Gtk.Flags.PickFlags
instance GHC.Classes.Ord GI.Gtk.Flags.PopoverMenuFlags
instance GHC.Classes.Ord GI.Gtk.Flags.PrintCapabilities
instance GHC.Classes.Ord GI.Gtk.Flags.ShortcutActionFlags
instance GHC.Classes.Ord GI.Gtk.Flags.StateFlags
instance GHC.Classes.Ord GI.Gtk.Flags.StyleContextPrintFlags
instance GHC.Classes.Ord GI.Gtk.Flags.SvgFeatures
instance GHC.Classes.Ord GI.Gtk.Flags.TextBufferNotifyFlags
instance GHC.Classes.Ord GI.Gtk.Flags.TextSearchFlags
instance GHC.Classes.Ord GI.Gtk.Flags.TreeModelFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.ApplicationInhibitFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.BuilderClosureFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.CellRendererState
instance GHC.Internal.Show.Show GI.Gtk.Flags.DebugFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.DialogFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.EventControllerScrollFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.FontChooserLevel
instance GHC.Internal.Show.Show GI.Gtk.Flags.IconLookupFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.InputHints
instance GHC.Internal.Show.Show GI.Gtk.Flags.ListScrollFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.PickFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.PopoverMenuFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.PrintCapabilities
instance GHC.Internal.Show.Show GI.Gtk.Flags.ShortcutActionFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.StateFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.StyleContextPrintFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.SvgFeatures
instance GHC.Internal.Show.Show GI.Gtk.Flags.TextBufferNotifyFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.TextSearchFlags
instance GHC.Internal.Show.Show GI.Gtk.Flags.TreeModelFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.ApplicationInhibitFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.BuilderClosureFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.CellRendererState
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.DebugFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.DialogFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.EventControllerScrollFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.FontChooserLevel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.IconLookupFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.InputHints
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.ListScrollFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.PickFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.PopoverMenuFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.PrintCapabilities
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.ShortcutActionFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.StateFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.StyleContextPrintFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.SvgFeatures
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.TextBufferNotifyFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.TextSearchFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Flags.TreeModelFlags


-- | Allows objects to extend and customize deserialization from ui files.
--   
--   The <tt>GtkBuildable</tt> interface includes methods for setting names
--   and properties of objects, parsing custom tags and constructing child
--   objects.
--   
--   It is implemented by all widgets and many of the non-widget objects
--   that are provided by GTK. The main user of this interface is
--   <a>Builder</a>. There should be very little need for applications to
--   call any of these functions directly.
--   
--   An object only needs to implement this interface if it needs to extend
--   the <tt>GtkBuilder</tt> XML format or run any extra routines at
--   deserialization time.
module GI.Gtk.Interfaces.Buildable

-- | Memory-managed wrapper type.
newtype Buildable
Buildable :: ManagedPtr Buildable -> Buildable

-- | Type class for types which can be safely cast to <a>Buildable</a>, for
--   instance with <a>toBuildable</a>.
class (GObject o, IsDescendantOf Buildable o) => IsBuildable o

-- | Cast to <a>Buildable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBuildable :: (MonadIO m, IsBuildable o) => o -> m Buildable

-- | Gets the ID of the <i><tt>buildable</tt></i> object.
--   
--   <tt>GtkBuilder</tt> sets the name based on the ID attribute of the
--   <tt>&lt;object&gt;</tt> tag used to construct the
--   <i><tt>buildable</tt></i>.
buildableGetBuildableId :: (HasCallStack, MonadIO m, IsBuildable a) => a -> m (Maybe Text)
instance GHC.Classes.Eq GI.Gtk.Interfaces.Buildable.Buildable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Buildable.Buildable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Buildable.Buildable
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Buildable.Buildable o) => GI.Gtk.Interfaces.Buildable.IsBuildable o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Buildable.Buildable)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Buildable.Buildable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Buildable.Buildable


-- | Provides language binding support to <tt>GtkBuilder</tt>.
--   
--   The goal of <tt>GtkBuilderScope</tt> is to look up
--   programming-language-specific values for strings that are given in a
--   <tt>GtkBuilder</tt> UI file.
--   
--   The primary intended audience is bindings that want to provide deeper
--   integration of <tt>GtkBuilder</tt> into the language.
--   
--   A <tt>GtkBuilderScope</tt> instance may be used with multiple
--   <tt>GtkBuilder</tt> objects, even at once.
--   
--   By default, GTK will use its own implementation of
--   <tt>GtkBuilderScope</tt> for the C language which can be created via
--   <a>builderCScopeNew</a>.
--   
--   If you implement <tt>GtkBuilderScope</tt> for a language binding, you
--   may want to (partially) derive from or fall back to a
--   <a>BuilderCScope</a>, as that class implements support for automatic
--   lookups from C symbols.
module GI.Gtk.Interfaces.BuilderScope

-- | Memory-managed wrapper type.
newtype BuilderScope
BuilderScope :: ManagedPtr BuilderScope -> BuilderScope

-- | Type class for types which can be safely cast to <a>BuilderScope</a>,
--   for instance with <a>toBuilderScope</a>.
class (GObject o, IsDescendantOf BuilderScope o) => IsBuilderScope o

-- | Cast to <a>BuilderScope</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBuilderScope :: (MonadIO m, IsBuilderScope o) => o -> m BuilderScope
instance GHC.Classes.Eq GI.Gtk.Interfaces.BuilderScope.BuilderScope
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.BuilderScope.BuilderScope
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.BuilderScope.BuilderScope
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.BuilderScope.BuilderScope o) => GI.Gtk.Interfaces.BuilderScope.IsBuilderScope o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.BuilderScope.BuilderScope)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.BuilderScope.BuilderScope
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.BuilderScope.BuilderScope


-- | <tt>GtkColorChooser</tt> is an interface that is implemented by
--   widgets for choosing colors.
--   
--   Depending on the situation, colors may be allowed to have alpha
--   (translucency).
--   
--   In GTK, the main widgets that implement this interface are
--   <a>ColorChooserWidget</a>, <a>ColorChooserDialog</a> and
--   <a>ColorButton</a>.
module GI.Gtk.Interfaces.ColorChooser

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> and
--   <a>ColorDialogButton</a>instead of widgets implementing
--   <tt>GtkColorChooser</tt></i>
newtype ColorChooser

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> and
--   <a>ColorDialogButton</a>instead of widgets implementing
--   <tt>GtkColorChooser</tt></i>
ColorChooser :: ManagedPtr ColorChooser -> ColorChooser

-- | Type class for types which can be safely cast to <a>ColorChooser</a>,
--   for instance with <a>toColorChooser</a>.
class (GObject o, IsDescendantOf ColorChooser o) => IsColorChooser o

-- | Cast to <a>ColorChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColorChooser :: (MonadIO m, IsColorChooser o) => o -> m ColorChooser

-- | Adds a palette to the color chooser.
--   
--   If <i><tt>orientation</tt></i> is horizontal, the colors are grouped
--   in rows, with <i><tt>colorsPerLine</tt></i> colors in each row. If
--   <i><tt>horizontal</tt></i> is <a>False</a>, the colors are grouped in
--   columns instead.
--   
--   The default color palette of <a>ColorChooserWidget</a> has 45 colors,
--   organized in columns of 5 colors (this includes some grays).
--   
--   The layout of the color chooser widget works best when the palettes
--   have 9-10 columns.
--   
--   Calling this function for the first time has the side effect of
--   removing the default color palette from the color chooser.
--   
--   If <i><tt>colors</tt></i> is <a>Nothing</a>, removes all previously
--   added palettes.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> instead</i>
colorChooserAddPalette :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Orientation -> Int32 -> Maybe [RGBA] -> m ()

-- | Gets the currently-selected color.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> instead</i>
colorChooserGetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m RGBA

-- | Returns whether the color chooser shows the alpha channel.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> instead</i>
colorChooserGetUseAlpha :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> m Bool

-- | Sets the color.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> instead</i>
colorChooserSetRgba :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> RGBA -> m ()

-- | Sets whether or not the color chooser should use the alpha channel.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> instead</i>
colorChooserSetUseAlpha :: (HasCallStack, MonadIO m, IsColorChooser a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rgba</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorChooserRgba :: (IsColorChooser o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooser #rgba
--   </pre>
getColorChooserRgba :: (MonadIO m, IsColorChooser o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooser [ #rgba <a>:=</a> value ]
--   </pre>
setColorChooserRgba :: (MonadIO m, IsColorChooser o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-alpha</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColorChooserUseAlpha :: (IsColorChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooser #useAlpha
--   </pre>
getColorChooserUseAlpha :: (MonadIO m, IsColorChooser o) => o -> m Bool

-- | Set the value of the “<tt>use-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooser [ #useAlpha <a>:=</a> value ]
--   </pre>
setColorChooserUseAlpha :: (MonadIO m, IsColorChooser o) => o -> Bool -> m ()

-- | Emitted when a color is activated from the color chooser.
--   
--   This usually happens when the user clicks a color swatch, or a color
--   is selected and the user presses one of the keys Space, Shift+Space,
--   Return or Enter.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> and
--   <a>ColorDialogButton</a>instead of widgets implementing
--   <tt>GtkColorChooser</tt></i>
type ColorChooserColorActivatedCallback = RGBA -> IO ()

-- | Connect a signal handler for the <a>colorActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> colorChooser #colorActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColorChooserColorActivated :: (IsColorChooser a, MonadIO m) => a -> ((?self :: a) => ColorChooserColorActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>colorActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> colorChooser #colorActivated callback
--   </pre>
onColorChooserColorActivated :: (IsColorChooser a, MonadIO m) => a -> ((?self :: a) => ColorChooserColorActivatedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.ColorChooser.ColorChooser
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.ColorChooser.ColorChooser
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.ColorChooser.ColorChooser
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.ColorChooser.ColorChooser o) => GI.Gtk.Interfaces.ColorChooser.IsColorChooser o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.ColorChooser.ColorChooser)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.ColorChooser.ColorChooser
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.ColorChooser.ColorChooser


-- | Makes it possible to use an object as source or target in a
--   <a>Constraint</a>.
--   
--   Besides <tt>GtkWidget</tt>, it is also implemented by
--   <tt>GtkConstraintGuide</tt>.
module GI.Gtk.Interfaces.ConstraintTarget

-- | Memory-managed wrapper type.
newtype ConstraintTarget
ConstraintTarget :: ManagedPtr ConstraintTarget -> ConstraintTarget

-- | Type class for types which can be safely cast to
--   <a>ConstraintTarget</a>, for instance with <a>toConstraintTarget</a>.
class (GObject o, IsDescendantOf ConstraintTarget o) => IsConstraintTarget o

-- | Cast to <a>ConstraintTarget</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toConstraintTarget :: (MonadIO m, IsConstraintTarget o) => o -> m ConstraintTarget
instance GHC.Classes.Eq GI.Gtk.Interfaces.ConstraintTarget.ConstraintTarget
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.ConstraintTarget.ConstraintTarget
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.ConstraintTarget.ConstraintTarget
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.ConstraintTarget.ConstraintTarget o) => GI.Gtk.Interfaces.ConstraintTarget.IsConstraintTarget o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.ConstraintTarget.ConstraintTarget)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.ConstraintTarget.ConstraintTarget
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.ConstraintTarget.ConstraintTarget


-- | An interface for widgets that can be oriented horizontally or
--   vertically.
--   
--   <tt>GtkOrientable</tt> is more flexible in that it allows the
--   orientation to be changed at runtime, allowing the widgets to “flip”.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkWidget</tt> types implementing the <tt>GtkOrientable</tt>
--   interface will automatically acquire the <tt>horizontal</tt> or
--   <tt>vertical</tt> CSS class depending on the value of the
--   <a>Orientable:orientation</a> property.
module GI.Gtk.Interfaces.Orientable

-- | Memory-managed wrapper type.
newtype Orientable
Orientable :: ManagedPtr Orientable -> Orientable

-- | Type class for types which can be safely cast to <a>Orientable</a>,
--   for instance with <a>toOrientable</a>.
class (GObject o, IsDescendantOf Orientable o) => IsOrientable o

-- | Cast to <a>Orientable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toOrientable :: (MonadIO m, IsOrientable o) => o -> m Orientable

-- | Retrieves the orientation of the <i><tt>orientable</tt></i>.
orientableGetOrientation :: (HasCallStack, MonadIO m, IsOrientable a) => a -> m Orientation

-- | Sets the orientation of the <i><tt>orientable</tt></i>.
orientableSetOrientation :: (HasCallStack, MonadIO m, IsOrientable a) => a -> Orientation -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>orientation</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructOrientableOrientation :: (IsOrientable o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Get the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> orientable #orientation
--   </pre>
getOrientableOrientation :: (MonadIO m, IsOrientable o) => o -> m Orientation

-- | Set the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> orientable [ #orientation <a>:=</a> value ]
--   </pre>
setOrientableOrientation :: (MonadIO m, IsOrientable o) => o -> Orientation -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.Orientable.Orientable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Orientable.Orientable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Orientable.Orientable
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Orientable.Orientable)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Orientable.Orientable o) => GI.Gtk.Interfaces.Orientable.IsOrientable o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Orientable.Orientable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Orientable.Orientable


-- | An interface that adds support for sections to list models.
--   
--   A <tt>GtkSectionModel</tt> groups successive items into so-called
--   sections. List widgets like <tt>GtkListView</tt> and
--   <tt>GtkGridView</tt> then allow displaying section headers for these
--   sections by installing a header factory.
--   
--   Many GTK list models support sections inherently, or they pass through
--   the sections of a model they are wrapping.
--   
--   When the section groupings of a model change, the model will emit the
--   <a>SectionModel::sectionsChanged</a> signal by calling the
--   <a>sectionModelSectionsChanged</a> function. All sections in the given
--   range then need to be queried again. The
--   <a>ListModel::itemsChanged</a> signal has the same effect, all
--   sections in that range are invalidated, too.
--   
--   <i>Since: 4.12</i>
module GI.Gtk.Interfaces.SectionModel

-- | Memory-managed wrapper type.
newtype SectionModel
SectionModel :: ManagedPtr SectionModel -> SectionModel

-- | Type class for types which can be safely cast to <a>SectionModel</a>,
--   for instance with <a>toSectionModel</a>.
class (GObject o, IsDescendantOf SectionModel o) => IsSectionModel o

-- | Cast to <a>SectionModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSectionModel :: (MonadIO m, IsSectionModel o) => o -> m SectionModel

-- | Query the section that covers the given position. The number of items
--   in the section can be computed by <tt>out_end - out_start</tt>.
--   
--   If the position is larger than the number of items, a single range
--   from n_items to G_MAXUINT will be returned.
--   
--   <i>Since: 4.12</i>
sectionModelGetSection :: (HasCallStack, MonadIO m, IsSectionModel a) => a -> Word32 -> m (Word32, Word32)

-- | This function emits the <a>SectionModel::sectionsChanged</a> signal to
--   notify about changes to sections.
--   
--   It must cover all positions that used to be a section start or that
--   are now a section start. It does not have to cover all positions for
--   which the section has changed.
--   
--   The <a>ListModel::itemsChanged</a> implies the effect of the
--   <a>SectionModel::sectionsChanged</a> signal for all the items it
--   covers.
--   
--   It is recommended that when changes to the items cause section changes
--   in a larger range, that the larger range is included in the emission
--   of the <a>ListModel::itemsChanged</a> instead of emitting two signals.
--   
--   <i>Since: 4.12</i>
sectionModelSectionsChanged :: (HasCallStack, MonadIO m, IsSectionModel a) => a -> Word32 -> Word32 -> m ()

-- | Emitted when the start-of-section state of some of the items in
--   <i><tt>model</tt></i> changes.
--   
--   Note that this signal does not specify the new section state of the
--   items, they need to be queried manually. It is also not necessary for
--   a model to change the section state of any of the items in the section
--   model, though it would be rather useless to emit such a signal.
--   
--   The <a>ListModel::itemsChanged</a> implies the effect of the
--   <a>SectionModel::sectionsChanged</a> signal for all the items it
--   covers.
--   
--   <i>Since: 4.12</i>
type SectionModelSectionsChangedCallback = Word32 -> Word32 -> IO ()

-- | Connect a signal handler for the <a>sectionsChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> sectionModel #sectionsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSectionModelSectionsChanged :: (IsSectionModel a, MonadIO m) => a -> ((?self :: a) => SectionModelSectionsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sectionsChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> sectionModel #sectionsChanged callback
--   </pre>
onSectionModelSectionsChanged :: (IsSectionModel a, MonadIO m) => a -> ((?self :: a) => SectionModelSectionsChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.SectionModel.SectionModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.SectionModel.SectionModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.SectionModel.SectionModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.SectionModel.SectionModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.SectionModel.SectionModel o) => GI.Gtk.Interfaces.SectionModel.IsSectionModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.SectionModel.SectionModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.SectionModel.SectionModel


-- | An interface that is used to implement shortcut scopes.
--   
--   This is important for <a>Native</a> widgets that have their own
--   surface, since the event controllers that are used to implement
--   managed and global scopes are limited to the same native.
--   
--   Examples for widgets implementing <tt>GtkShortcutManager</tt> are
--   <a>Window</a> and <a>Popover</a>.
--   
--   Every widget that implements <tt>GtkShortcutManager</tt> will be used
--   as a <tt>GTK_SHORTCUT_SCOPE_MANAGED</tt>.
module GI.Gtk.Interfaces.ShortcutManager

-- | Memory-managed wrapper type.
newtype ShortcutManager
ShortcutManager :: ManagedPtr ShortcutManager -> ShortcutManager

-- | Type class for types which can be safely cast to
--   <a>ShortcutManager</a>, for instance with <a>toShortcutManager</a>.
class (GObject o, IsDescendantOf ShortcutManager o) => IsShortcutManager o

-- | Cast to <a>ShortcutManager</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutManager :: (MonadIO m, IsShortcutManager o) => o -> m ShortcutManager
instance GHC.Classes.Eq GI.Gtk.Interfaces.ShortcutManager.ShortcutManager
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.ShortcutManager.ShortcutManager
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.ShortcutManager.ShortcutManager
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.ShortcutManager.ShortcutManager)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.ShortcutManager.ShortcutManager o) => GI.Gtk.Interfaces.ShortcutManager.IsShortcutManager o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.ShortcutManager.ShortcutManager
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.ShortcutManager.ShortcutManager


-- | An interface for style information used by <a>StyleContext</a>.
--   
--   See <a>styleContextAddProvider</a> and
--   <a>styleContextAddProviderForDisplay</a> for adding
--   <tt>GtkStyleProviders</tt>.
--   
--   GTK uses the <tt>GtkStyleProvider</tt> implementation for CSS in
--   <a>CssProvider</a>.
module GI.Gtk.Interfaces.StyleProvider

-- | Memory-managed wrapper type.
newtype StyleProvider
StyleProvider :: ManagedPtr StyleProvider -> StyleProvider

-- | Type class for types which can be safely cast to <a>StyleProvider</a>,
--   for instance with <a>toStyleProvider</a>.
class (GObject o, IsDescendantOf StyleProvider o) => IsStyleProvider o

-- | Cast to <a>StyleProvider</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStyleProvider :: (MonadIO m, IsStyleProvider o) => o -> m StyleProvider

-- | <i>No description available in the introspection data.</i>
type StyleProviderGtkPrivateChangedCallback = IO ()

-- | Connect a signal handler for the <a>gtkPrivateChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> styleProvider #gtkPrivateChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStyleProviderGtkPrivateChanged :: (IsStyleProvider a, MonadIO m) => a -> ((?self :: a) => StyleProviderGtkPrivateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>gtkPrivateChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> styleProvider #gtkPrivateChanged callback
--   </pre>
onStyleProviderGtkPrivateChanged :: (IsStyleProvider a, MonadIO m) => a -> ((?self :: a) => StyleProviderGtkPrivateChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.StyleProvider.StyleProvider
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.StyleProvider.StyleProvider
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.StyleProvider.StyleProvider
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.StyleProvider.StyleProvider)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.StyleProvider.StyleProvider o) => GI.Gtk.Interfaces.StyleProvider.IsStyleProvider o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.StyleProvider.StyleProvider
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.StyleProvider.StyleProvider


-- | An interface that supports symbolic colors in paintables.
--   
--   <tt>GdkPaintable</tt>s implementing the interface will have the
--   <a>SymbolicPaintable</a>.<tt><i>snapshot_symbolic</i></tt>() function
--   called and have the colors for drawing symbolic icons passed. At least
--   5 colors are guaranteed to be passed every time. These 5 colors are
--   the foreground color, and the colors to use for errors, warnings and
--   success information in that order, followed by the system accent
--   color.
--   
--   The system accent color has been added in GTK 4.22. More colors may be
--   added in the future.
--   
--   <i>Since: 4.6</i>
module GI.Gtk.Interfaces.SymbolicPaintable

-- | Memory-managed wrapper type.
newtype SymbolicPaintable
SymbolicPaintable :: ManagedPtr SymbolicPaintable -> SymbolicPaintable

-- | Type class for types which can be safely cast to
--   <a>SymbolicPaintable</a>, for instance with
--   <a>toSymbolicPaintable</a>.
class (GObject o, IsDescendantOf SymbolicPaintable o) => IsSymbolicPaintable o

-- | Cast to <a>SymbolicPaintable</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSymbolicPaintable :: (MonadIO m, IsSymbolicPaintable o) => o -> m SymbolicPaintable

-- | Snapshots the paintable with the given colors.
--   
--   If less than 5 colors are provided, GTK will pad the array with
--   default colors.
--   
--   <i>Since: 4.6</i>
symbolicPaintableSnapshotSymbolic :: (HasCallStack, MonadIO m, IsSymbolicPaintable a, IsSnapshot b) => a -> b -> Double -> Double -> [RGBA] -> m ()

-- | Snapshots the paintable with the given colors and weight.
--   
--   If less than 5 colors are provided, GTK will pad the array with
--   default colors.
--   
--   <i>Since: 4.22</i>
symbolicPaintableSnapshotWithWeight :: (HasCallStack, MonadIO m, IsSymbolicPaintable a, IsSnapshot b) => a -> b -> Double -> Double -> [RGBA] -> Double -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable o) => GI.Gtk.Interfaces.SymbolicPaintable.IsSymbolicPaintable o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.SymbolicPaintable.SymbolicPaintable


-- | Communicates with platform-specific assistive technologies API.
--   
--   Each platform supported by GTK implements a <tt>GtkATContext</tt>
--   subclass, and is responsible for updating the accessible state in
--   response to state changes in <tt>GtkAccessible</tt>.
module GI.Gtk.Objects.ATContext

-- | Memory-managed wrapper type.
newtype ATContext
ATContext :: ManagedPtr ATContext -> ATContext

-- | Type class for types which can be safely cast to <a>ATContext</a>, for
--   instance with <a>toATContext</a>.
class (GObject o, IsDescendantOf ATContext o) => IsATContext o

-- | Cast to <a>ATContext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toATContext :: (MonadIO m, IsATContext o) => o -> m ATContext

-- | Creates a new <tt>GtkATContext</tt> instance for the given accessible
--   role, accessible instance, and display connection.
--   
--   The <tt>GtkATContext</tt> implementation being instantiated will
--   depend on the platform.
aTContextCreate :: (HasCallStack, MonadIO m, IsAccessible a, IsDisplay b) => AccessibleRole -> a -> b -> m (Maybe ATContext)

-- | Retrieves the <tt>GtkAccessible</tt> using this context.
aTContextGetAccessible :: (HasCallStack, MonadIO m, IsATContext a) => a -> m Accessible

-- | Retrieves the accessible role of this context.
aTContextGetAccessibleRole :: (HasCallStack, MonadIO m, IsATContext a) => a -> m AccessibleRole

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accessible</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructATContextAccessible :: (IsATContext o, MonadIO m, IsAccessible a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>accessible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aTContext #accessible
--   </pre>
getATContextAccessible :: (MonadIO m, IsATContext o) => o -> m Accessible

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accessible-role</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructATContextAccessibleRole :: (IsATContext o, MonadIO m) => AccessibleRole -> m (GValueConstruct o)

-- | Get the value of the “<tt>accessible-role</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aTContext #accessibleRole
--   </pre>
getATContextAccessibleRole :: (MonadIO m, IsATContext o) => o -> m AccessibleRole

-- | Set the value of the “<tt>accessible-role</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aTContext [ #accessibleRole <a>:=</a> value ]
--   </pre>
setATContextAccessibleRole :: (MonadIO m, IsATContext o) => o -> AccessibleRole -> m ()

-- | Set the value of the “<tt>display</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #display
--   </pre>
clearATContextDisplay :: (MonadIO m, IsATContext o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>display</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructATContextDisplay :: (IsATContext o, MonadIO m, IsDisplay a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aTContext #display
--   </pre>
getATContextDisplay :: (MonadIO m, IsATContext o) => o -> m (Maybe Display)

-- | Set the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aTContext [ #display <a>:=</a> value ]
--   </pre>
setATContextDisplay :: (MonadIO m, IsATContext o, IsDisplay a) => o -> a -> m ()

-- | Emitted when the attributes of the accessible for the
--   <tt>GtkATContext</tt> instance change.
type ATContextStateChangeCallback = IO ()

-- | Connect a signal handler for the <a>stateChange</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> aTContext #stateChange callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterATContextStateChange :: (IsATContext a, MonadIO m) => a -> ((?self :: a) => ATContextStateChangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateChange</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> aTContext #stateChange callback
--   </pre>
onATContextStateChange :: (IsATContext a, MonadIO m) => a -> ((?self :: a) => ATContextStateChangeCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ATContext.ATContext
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ATContext.ATContext
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ATContext.ATContext
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ATContext.ATContext o) => GI.Gtk.Objects.ATContext.IsATContext o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ATContext.ATContext)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ATContext.ATContext
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ATContext.ATContext


-- | An interface for accessible objects containing formatted text.
--   
--   The <tt>GtkAccessibleText</tt> interfaces is meant to be implemented
--   by accessible objects that have text formatted with attributes, or
--   non-trivial text contents.
--   
--   You should use the <a>AccessiblePropertyLabel</a> or the
--   <a>AccessiblePropertyDescription</a> properties for accessible objects
--   containing simple, unformatted text.
--   
--   <i>Since: 4.14</i>
module GI.Gtk.Interfaces.AccessibleText

-- | Memory-managed wrapper type.
newtype AccessibleText
AccessibleText :: ManagedPtr AccessibleText -> AccessibleText

-- | Type class for types which can be safely cast to
--   <a>AccessibleText</a>, for instance with <a>toAccessibleText</a>.
class (GObject o, IsDescendantOf AccessibleText o) => IsAccessibleText o

-- | Cast to <a>AccessibleText</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAccessibleText :: (MonadIO m, IsAccessibleText o) => o -> m AccessibleText

-- | Updates the position of the caret.
--   
--   Implementations of the <tt>GtkAccessibleText</tt> interface should
--   call this function every time the caret has moved, in order to notify
--   assistive technologies.
--   
--   <i>Since: 4.14</i>
accessibleTextUpdateCaretPosition :: (HasCallStack, MonadIO m, IsAccessibleText a) => a -> m ()

-- | Notifies assistive technologies of a change in contents.
--   
--   Implementations of the <tt>GtkAccessibleText</tt> interface should
--   call this function every time their contents change as the result of
--   an operation, like an insertion or a removal.
--   
--   Note: If the change is a deletion, this function must be called
--   *before* removing the contents, if it is an insertion, it must be
--   called *after* inserting the new contents.
--   
--   <i>Since: 4.14</i>
accessibleTextUpdateContents :: (HasCallStack, MonadIO m, IsAccessibleText a) => a -> AccessibleTextContentChange -> Word32 -> Word32 -> m ()

-- | Updates the boundary of the selection.
--   
--   Implementations of the <tt>GtkAccessibleText</tt> interface should
--   call this function every time the selection has moved, in order to
--   notify assistive technologies.
--   
--   <i>Since: 4.14</i>
accessibleTextUpdateSelectionBound :: (HasCallStack, MonadIO m, IsAccessibleText a) => a -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.AccessibleText.AccessibleText
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.AccessibleText.AccessibleText
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.AccessibleText.AccessibleText
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.AccessibleText.AccessibleText o) => GI.Gtk.Interfaces.AccessibleText.IsAccessibleText o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.AccessibleText.AccessibleText)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.AccessibleText.AccessibleText
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.AccessibleText.AccessibleText


-- | An interface for accessible objects containing a numeric value.
--   
--   <tt>GtkAccessibleRange</tt> describes ranged controls for Assistive
--   Technologies.
--   
--   Ranged controls have a single value within an allowed range that can
--   optionally be changed by the user.
--   
--   This interface is expected to be implemented by controls using the
--   following roles:
--   
--   <ul>
--   <li><pre>GTK_ACCESSIBLE_ROLE_METER</pre></li>
--   <li><pre>GTK_ACCESSIBLE_ROLE_PROGRESS_BAR</pre></li>
--   <li><pre>GTK_ACCESSIBLE_ROLE_SCROLLBAR</pre></li>
--   <li><pre>GTK_ACCESSIBLE_ROLE_SLIDER</pre></li>
--   <li><pre>GTK_ACCESSIBLE_ROLE_SPIN_BUTTON</pre></li>
--   </ul>
--   
--   If that is not the case, a warning will be issued at run time.
--   
--   In addition to this interface, its implementers are expected to
--   provide the correct values for the following properties:
--   
--   <ul>
--   <li><pre>GTK_ACCESSIBLE_PROPERTY_VALUE_MAX</pre></li>
--   <li><pre>GTK_ACCESSIBLE_PROPERTY_VALUE_MIN</pre></li>
--   <li><pre>GTK_ACCESSIBLE_PROPERTY_VALUE_NOW</pre></li>
--   <li><pre>GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT</pre></li>
--   </ul>
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Interfaces.AccessibleRange

-- | Memory-managed wrapper type.
newtype AccessibleRange
AccessibleRange :: ManagedPtr AccessibleRange -> AccessibleRange

-- | Type class for types which can be safely cast to
--   <a>AccessibleRange</a>, for instance with <a>toAccessibleRange</a>.
class (GObject o, IsDescendantOf AccessibleRange o) => IsAccessibleRange o

-- | Cast to <a>AccessibleRange</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toAccessibleRange :: (MonadIO m, IsAccessibleRange o) => o -> m AccessibleRange
instance GHC.Classes.Eq GI.Gtk.Interfaces.AccessibleRange.AccessibleRange
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.AccessibleRange.AccessibleRange
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.AccessibleRange.AccessibleRange
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.AccessibleRange.AccessibleRange o) => GI.Gtk.Interfaces.AccessibleRange.IsAccessibleRange o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.AccessibleRange.AccessibleRange)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.AccessibleRange.AccessibleRange
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.AccessibleRange.AccessibleRange


-- | An interface for accessible objects containing links.
--   
--   The <tt>GtkAccessibleHypertext</tt> interfaces is meant to be
--   implemented by accessible objects that contain links. Those links
--   don't necessarily have to be part of text, they can be associated with
--   images and other things.
--   
--   <i>Since: 4.22</i>
module GI.Gtk.Interfaces.AccessibleHypertext

-- | Memory-managed wrapper type.
newtype AccessibleHypertext
AccessibleHypertext :: ManagedPtr AccessibleHypertext -> AccessibleHypertext

-- | Type class for types which can be safely cast to
--   <a>AccessibleHypertext</a>, for instance with
--   <a>toAccessibleHypertext</a>.
class (GObject o, IsDescendantOf AccessibleHypertext o) => IsAccessibleHypertext o

-- | Cast to <a>AccessibleHypertext</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toAccessibleHypertext :: (MonadIO m, IsAccessibleHypertext o) => o -> m AccessibleHypertext
instance GHC.Classes.Eq GI.Gtk.Interfaces.AccessibleHypertext.AccessibleHypertext
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.AccessibleHypertext.AccessibleHypertext
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.AccessibleHypertext.AccessibleHypertext
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.AccessibleHypertext.AccessibleHypertext o) => GI.Gtk.Interfaces.AccessibleHypertext.IsAccessibleHypertext o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.AccessibleHypertext.AccessibleHypertext)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.AccessibleHypertext.AccessibleHypertext
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.AccessibleHypertext.AccessibleHypertext


-- | An interface for describing UI elements for Assistive Technologies.
--   
--   Every accessible implementation has:
--   
--   <ul>
--   <li>a “role”, represented by a value of the <a>AccessibleRole</a>
--   enumeration</li>
--   <li>“attributes”, represented by a set of <a>AccessibleState</a>,
--   <a>AccessibleProperty</a> and <a>AccessibleRelation</a> values</li>
--   </ul>
--   
--   The role cannot be changed after instantiating a
--   <tt>GtkAccessible</tt> implementation.
--   
--   The attributes are updated every time a UI element's state changes in
--   a way that should be reflected by assistive technologies. For
--   instance, if a <tt>GtkWidget</tt> visibility changes, the
--   <a>AccessibleStateHidden</a> state will also change to reflect the
--   <a>Widget:visible</a> property.
--   
--   Every accessible implementation is part of a tree of accessible
--   objects. Normally, this tree corresponds to the widget tree, but can
--   be customized by reimplementing the
--   <a>Accessible</a>.<tt><i>get_accessible_parent</i></tt>(),
--   <a>Accessible</a>.<tt><i>get_first_accessible_child</i></tt>() and
--   <a>Accessible</a>.<tt><i>get_next_accessible_sibling</i></tt>()
--   virtual functions.
--   
--   Note that you can not create a top-level accessible object as of now,
--   which means that you must always have a parent accessible object.
--   
--   Also note that when an accessible object does not correspond to a
--   widget, and it has children, whose implementation you don't control,
--   it is necessary to ensure the correct shape of the a11y tree by
--   calling <a>accessibleSetAccessibleParent</a> and updating the sibling
--   by <a>accessibleUpdateNextAccessibleSibling</a>.
module GI.Gtk.Interfaces.Accessible

-- | Memory-managed wrapper type.
newtype Accessible
Accessible :: ManagedPtr Accessible -> Accessible

-- | Type class for types which can be safely cast to <a>Accessible</a>,
--   for instance with <a>toAccessible</a>.
class (GObject o, IsDescendantOf Accessible o) => IsAccessible o

-- | Cast to <a>Accessible</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAccessible :: (MonadIO m, IsAccessible o) => o -> m Accessible

-- | Requests the user's screen reader to announce the given message.
--   
--   This kind of notification is useful for messages that either have only
--   a visual representation or that are not exposed visually at all, e.g.
--   a notification about a successful operation.
--   
--   Also, by using this API, you can ensure that the message does not
--   interrupts the user's current screen reader output.
--   
--   <i>Since: 4.14</i>
accessibleAnnounce :: (HasCallStack, MonadIO m, IsAccessible a) => a -> Text -> AccessibleAnnouncementPriority -> m ()

-- | Retrieves the accessible identifier for the accessible object.
--   
--   This functionality can be overridden by <tt>GtkAccessible</tt>
--   implementations.
--   
--   It is left to the accessible implementation to define the scope and
--   uniqueness of the identifier.
--   
--   <i>Since: 4.22</i>
accessibleGetAccessibleId :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m (Maybe Text)

-- | Retrieves the accessible parent for an accessible object.
--   
--   This function returns <tt>NULL</tt> for top level widgets.
--   
--   <i>Since: 4.10</i>
accessibleGetAccessibleParent :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m (Maybe Accessible)

-- | Retrieves the accessible role of an accessible object.
accessibleGetAccessibleRole :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m AccessibleRole

-- | Retrieves the implementation for the given accessible object.
--   
--   <i>Since: 4.10</i>
accessibleGetAtContext :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m ATContext

-- | Queries the coordinates and dimensions of this accessible
--   
--   This functionality can be overridden by <tt>GtkAccessible</tt>
--   implementations, e.g. to get the bounds from an ignored child widget.
--   
--   <i>Since: 4.10</i>
accessibleGetBounds :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m (Bool, Int32, Int32, Int32, Int32)

-- | Retrieves the first accessible child of an accessible object.
--   
--   <i>Since: 4.10</i>
accessibleGetFirstAccessibleChild :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m (Maybe Accessible)

-- | Retrieves the next accessible sibling of an accessible object
--   
--   <i>Since: 4.10</i>
accessibleGetNextAccessibleSibling :: (HasCallStack, MonadIO m, IsAccessible a) => a -> m (Maybe Accessible)

-- | Queries a platform state, such as focus.
--   
--   This functionality can be overridden by <tt>GtkAccessible</tt>
--   implementations, e.g. to get platform state from an ignored child
--   widget, as is the case for <tt>GtkText</tt> wrappers.
--   
--   <i>Since: 4.10</i>
accessibleGetPlatformState :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessiblePlatformState -> m Bool

-- | Resets the accessible property to its default value.
accessibleResetProperty :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessibleProperty -> m ()

-- | Resets the accessible relation to its default value.
accessibleResetRelation :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessibleRelation -> m ()

-- | Resets the accessible state to its default value.
accessibleResetState :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessibleState -> m ()

-- | Sets the parent and sibling of an accessible object.
--   
--   This function is meant to be used by accessible implementations that
--   are not part of the widget hierarchy, and but act as a logical bridge
--   between widgets. For instance, if a widget creates an object that
--   holds metadata for each child, and you want that object to implement
--   the <tt>GtkAccessible</tt> interface, you will use this function to
--   ensure that the parent of each child widget is the metadata object,
--   and the parent of each metadata object is the container widget.
--   
--   <i>Since: 4.10</i>
accessibleSetAccessibleParent :: (HasCallStack, MonadIO m, IsAccessible a, IsAccessible b, IsAccessible c) => a -> Maybe b -> Maybe c -> m ()

-- | Updates the next accessible sibling.
--   
--   That might be useful when a new child of a custom accessible is
--   created, and it needs to be linked to a previous child.
--   
--   <i>Since: 4.10</i>
accessibleUpdateNextAccessibleSibling :: (HasCallStack, MonadIO m, IsAccessible a, IsAccessible b) => a -> Maybe b -> m ()

-- | Informs ATs that the platform state has changed.
--   
--   This function should be used by <tt>GtkAccessible</tt> implementations
--   that have a platform state but are not widgets. Widgets handle
--   platform states automatically.
--   
--   <i>Since: 4.18</i>
accessibleUpdatePlatformState :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessiblePlatformState -> m ()

-- | Updates an array of accessible properties.
--   
--   This function should be called by <tt>GtkWidget</tt> types whenever an
--   accessible property change must be communicated to assistive
--   technologies.
--   
--   This function is meant to be used by language bindings.
accessibleUpdateProperty :: (HasCallStack, MonadIO m, IsAccessible a) => a -> [AccessibleProperty] -> [GValue] -> m ()

-- | Updates an array of accessible relations.
--   
--   This function should be called by <tt>GtkWidget</tt> types whenever an
--   accessible relation change must be communicated to assistive
--   technologies.
--   
--   This function is meant to be used by language bindings.
accessibleUpdateRelation :: (HasCallStack, MonadIO m, IsAccessible a) => a -> [AccessibleRelation] -> [GValue] -> m ()

-- | Updates an array of accessible states.
--   
--   This function should be called by <tt>GtkWidget</tt> types whenever an
--   accessible state change must be communicated to assistive
--   technologies.
--   
--   This function is meant to be used by language bindings.
accessibleUpdateState :: (HasCallStack, MonadIO m, IsAccessible a) => a -> [AccessibleState] -> [GValue] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accessible-role</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAccessibleAccessibleRole :: (IsAccessible o, MonadIO m) => AccessibleRole -> m (GValueConstruct o)

-- | Get the value of the “<tt>accessible-role</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accessible #accessibleRole
--   </pre>
getAccessibleAccessibleRole :: (MonadIO m, IsAccessible o) => o -> m AccessibleRole

-- | Set the value of the “<tt>accessible-role</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accessible [ #accessibleRole <a>:=</a> value ]
--   </pre>
setAccessibleAccessibleRole :: (MonadIO m, IsAccessible o) => o -> AccessibleRole -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.Accessible.Accessible
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Accessible.Accessible
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Accessible.Accessible
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Accessible.Accessible o) => GI.Gtk.Interfaces.Accessible.IsAccessible o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Accessible.Accessible)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Accessible.Accessible
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Accessible.Accessible


-- | A model for a numeric value.
--   
--   The <tt>GtkAdjustment</tt> has an associated lower and upper bound. It
--   also contains step and page increments, and a page size.
--   
--   Adjustments are used within several GTK widgets, including
--   <a>SpinButton</a>, <a>Viewport</a>, <a>Scrollbar</a> and <a>Scale</a>.
--   
--   The <tt>GtkAdjustment</tt> object does not update the value itself.
--   Instead it is left up to the owner of the <tt>GtkAdjustment</tt> to
--   control the value.
module GI.Gtk.Objects.Adjustment

-- | Memory-managed wrapper type.
newtype Adjustment
Adjustment :: ManagedPtr Adjustment -> Adjustment

-- | Type class for types which can be safely cast to <a>Adjustment</a>,
--   for instance with <a>toAdjustment</a>.
class (GObject o, IsDescendantOf Adjustment o) => IsAdjustment o

-- | Cast to <a>Adjustment</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAdjustment :: (MonadIO m, IsAdjustment o) => o -> m Adjustment

-- | Updates the value of the adjustment to ensure that the given range is
--   contained in the current page.
--   
--   The current page goes from <tt>value</tt> to <tt>value</tt> +
--   <tt>page-size</tt>. If the range is larger than the page size, then
--   only the start of it will be in the current page.
--   
--   A <a>Adjustment::valueChanged</a> signal will be emitted if the value
--   is changed.
adjustmentClampPage :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> Double -> m ()

-- | Sets all properties of the adjustment at once.
--   
--   Use this function to avoid multiple emissions of the
--   <a>Adjustment::changed</a> signal. See <a>adjustmentSetLower</a> for
--   an alternative way of compressing multiple emissions of
--   <a>Adjustment::changed</a> into one.
adjustmentConfigure :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> Double -> Double -> Double -> Double -> Double -> m ()

-- | Retrieves the minimum value of the adjustment.
adjustmentGetLower :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Gets the smaller of step increment and page increment.
adjustmentGetMinimumIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the page increment of the adjustment.
adjustmentGetPageIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the page size of the adjustment.
adjustmentGetPageSize :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the step increment of the adjustment.
adjustmentGetStepIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Retrieves the maximum value of the adjustment.
adjustmentGetUpper :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Gets the current value of the adjustment.
adjustmentGetValue :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> m Double

-- | Creates a new <tt>GtkAdjustment</tt>.
adjustmentNew :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> Double -> Double -> Double -> m Adjustment

-- | Sets the minimum value of the adjustment.
--   
--   When setting multiple adjustment properties via their individual
--   setters, multiple <a>Adjustment::changed</a> signals will be emitted.
--   However, since the emission of the <a>Adjustment::changed</a> signal
--   is tied to the emission of the <a>notify</a> signals of the changed
--   properties, it’s possible to compress the <a>Adjustment::changed</a>
--   signals into one by calling <a>objectFreezeNotify</a> and
--   <a>objectThawNotify</a> around the calls to the individual setters.
--   
--   Alternatively, using a single <tt><i>g_object_set()</i></tt> for all
--   the properties to change, or using <a>adjustmentConfigure</a> has the
--   same effect.
adjustmentSetLower :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the page increment of the adjustment.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the <a>Adjustment::changed</a> signal when setting multiple
--   adjustment properties.
adjustmentSetPageIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the page size of the adjustment.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the <a>Adjustment::changed</a> signal when setting multiple
--   adjustment properties.
adjustmentSetPageSize :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the step increment of the adjustment.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the <a>Adjustment::changed</a> signal when setting multiple
--   adjustment properties.
adjustmentSetStepIncrement :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the maximum value of the adjustment.
--   
--   Note that values will be restricted by <tt>upper - page-size</tt> if
--   the page-size property is nonzero.
--   
--   See <a>adjustmentSetLower</a> about how to compress multiple emissions
--   of the <a>Adjustment::changed</a> signal when setting multiple
--   adjustment properties.
adjustmentSetUpper :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Sets the <tt>GtkAdjustment</tt> value.
--   
--   The value is clamped to lie between <a>Adjustment:lower</a> and
--   <a>Adjustment:upper</a>.
--   
--   Note that for adjustments which are used in a <tt>GtkScrollbar</tt>,
--   the effective range of allowed values goes from
--   <a>Adjustment:lower</a> to <a>Adjustment:upper</a> -
--   <a>Adjustment:pageSize</a>.
adjustmentSetValue :: (HasCallStack, MonadIO m, IsAdjustment a) => a -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>lower</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAdjustmentLower :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>lower</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #lower
--   </pre>
getAdjustmentLower :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>lower</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #lower <a>:=</a> value ]
--   </pre>
setAdjustmentLower :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-increment</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAdjustmentPageIncrement :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #pageIncrement
--   </pre>
getAdjustmentPageIncrement :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>page-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #pageIncrement <a>:=</a> value ]
--   </pre>
setAdjustmentPageIncrement :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAdjustmentPageSize :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #pageSize
--   </pre>
getAdjustmentPageSize :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>page-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #pageSize <a>:=</a> value ]
--   </pre>
setAdjustmentPageSize :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>step-increment</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAdjustmentStepIncrement :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>step-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #stepIncrement
--   </pre>
getAdjustmentStepIncrement :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>step-increment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #stepIncrement <a>:=</a> value ]
--   </pre>
setAdjustmentStepIncrement :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>upper</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAdjustmentUpper :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>upper</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #upper
--   </pre>
getAdjustmentUpper :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>upper</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #upper <a>:=</a> value ]
--   </pre>
setAdjustmentUpper :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAdjustmentValue :: (IsAdjustment o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> adjustment #value
--   </pre>
getAdjustmentValue :: (MonadIO m, IsAdjustment o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> adjustment [ #value <a>:=</a> value ]
--   </pre>
setAdjustmentValue :: (MonadIO m, IsAdjustment o) => o -> Double -> m ()

-- | Emitted when one or more of the <tt>GtkAdjustment</tt> properties have
--   been changed.
--   
--   Note that the <a>Adjustment:value</a> property is covered by the
--   <a>Adjustment::valueChanged</a> signal.
type AdjustmentChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> adjustment #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAdjustmentChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> adjustment #changed callback
--   </pre>
onAdjustmentChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentChangedCallback) -> m SignalHandlerId

-- | Emitted when the value has been changed.
type AdjustmentValueChangedCallback = IO ()

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> adjustment #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAdjustmentValueChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> adjustment #valueChanged callback
--   </pre>
onAdjustmentValueChanged :: (IsAdjustment a, MonadIO m) => a -> ((?self :: a) => AdjustmentValueChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Adjustment.Adjustment
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Adjustment.Adjustment
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Adjustment.Adjustment
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Adjustment.Adjustment o) => GI.Gtk.Objects.Adjustment.IsAdjustment o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Adjustment.Adjustment)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Adjustment.Adjustment
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Adjustment.Adjustment


-- | A list model that wraps <tt>GBookmarkFile</tt>.
--   
--   It presents a <tt>GListModel</tt> and fills it asynchronously with the
--   <tt>GFileInfo</tt>s returned from that function.
--   
--   The <tt>GFileInfo</tt>s in the list have some attributes in the recent
--   namespace added: <tt>recent::private</tt> (boolean) and
--   <tt>recent:applications</tt> (stringv).
module GI.Gtk.Objects.BookmarkList

-- | Memory-managed wrapper type.
newtype BookmarkList
BookmarkList :: ManagedPtr BookmarkList -> BookmarkList

-- | Type class for types which can be safely cast to <a>BookmarkList</a>,
--   for instance with <a>toBookmarkList</a>.
class (GObject o, IsDescendantOf BookmarkList o) => IsBookmarkList o

-- | Cast to <a>BookmarkList</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBookmarkList :: (MonadIO m, IsBookmarkList o) => o -> m BookmarkList

-- | Gets the attributes queried on the children.
bookmarkListGetAttributes :: (HasCallStack, MonadIO m, IsBookmarkList a) => a -> m (Maybe Text)

-- | Returns the filename of the bookmark file that this list is loading.
bookmarkListGetFilename :: (HasCallStack, MonadIO m, IsBookmarkList a) => a -> m [Char]

-- | Gets the IO priority to use while loading file.
bookmarkListGetIoPriority :: (HasCallStack, MonadIO m, IsBookmarkList a) => a -> m Int32

-- | Returns <a>True</a> if the files are currently being loaded.
--   
--   Files will be added to <i><tt>self</tt></i> from time to time while
--   loading is going on. The order in which are added is undefined and may
--   change in between runs.
bookmarkListIsLoading :: (HasCallStack, MonadIO m, IsBookmarkList a) => a -> m Bool

-- | Creates a new <tt>GtkBookmarkList</tt> with the given
--   <i><tt>attributes</tt></i>.
bookmarkListNew :: (HasCallStack, MonadIO m) => Maybe [Char] -> Maybe Text -> m BookmarkList

-- | Sets the <i><tt>attributes</tt></i> to be enumerated and starts the
--   enumeration.
--   
--   If <i><tt>attributes</tt></i> is <a>Nothing</a>, no attributes will be
--   queried, but a list of <tt>GFileInfo</tt>s will still be created.
bookmarkListSetAttributes :: (HasCallStack, MonadIO m, IsBookmarkList a) => a -> Maybe Text -> m ()

-- | Sets the IO priority to use while loading files.
--   
--   The default IO priority is <a>PRIORITY_DEFAULT</a>.
bookmarkListSetIoPriority :: (HasCallStack, MonadIO m, IsBookmarkList a) => a -> Int32 -> m ()

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearBookmarkListAttributes :: (MonadIO m, IsBookmarkList o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructBookmarkListAttributes :: (IsBookmarkList o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bookmarkList #attributes
--   </pre>
getBookmarkListAttributes :: (MonadIO m, IsBookmarkList o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bookmarkList [ #attributes <a>:=</a> value ]
--   </pre>
setBookmarkListAttributes :: (MonadIO m, IsBookmarkList o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filename</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructBookmarkListFilename :: (IsBookmarkList o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>filename</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bookmarkList #filename
--   </pre>
getBookmarkListFilename :: (MonadIO m, IsBookmarkList o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>io-priority</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructBookmarkListIoPriority :: (IsBookmarkList o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>io-priority</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bookmarkList #ioPriority
--   </pre>
getBookmarkListIoPriority :: (MonadIO m, IsBookmarkList o) => o -> m Int32

-- | Set the value of the “<tt>io-priority</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bookmarkList [ #ioPriority <a>:=</a> value ]
--   </pre>
setBookmarkListIoPriority :: (MonadIO m, IsBookmarkList o) => o -> Int32 -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bookmarkList #itemType
--   </pre>
getBookmarkListItemType :: (MonadIO m, IsBookmarkList o) => o -> m GType

-- | Get the value of the “<tt>loading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bookmarkList #loading
--   </pre>
getBookmarkListLoading :: (MonadIO m, IsBookmarkList o) => o -> m Bool

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bookmarkList #nItems
--   </pre>
getBookmarkListNItems :: (MonadIO m, IsBookmarkList o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.BookmarkList.BookmarkList
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.BookmarkList.BookmarkList
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.BookmarkList.BookmarkList
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.BookmarkList.BookmarkList o) => GI.Gtk.Objects.BookmarkList.IsBookmarkList o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.BookmarkList.BookmarkList)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.BookmarkList.BookmarkList
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.BookmarkList.BookmarkList


-- | Reads XML descriptions of a user interface and instantiates the
--   described objects.
--   
--   To create a <tt>GtkBuilder</tt> from a user interface description,
--   call <a>builderNewFromFile</a>, <a>builderNewFromResource</a> or
--   <a>builderNewFromString</a>.
--   
--   In the (unusual) case that you want to add user interface descriptions
--   from multiple sources to the same <tt>GtkBuilder</tt> you can call
--   <a>builderNew</a> to get an empty builder and populate it by
--   (multiple) calls to <a>builderAddFromFile</a>,
--   <a>builderAddFromResource</a> or <a>builderAddFromString</a>.
--   
--   A <tt>GtkBuilder</tt> holds a reference to all objects that it has
--   constructed and drops these references when it is finalized. This
--   finalization can cause the destruction of non-widget objects or
--   widgets which are not contained in a toplevel window. For toplevel
--   windows constructed by a builder, it is the responsibility of the user
--   to call <a>windowDestroy</a> to get rid of them and all the widgets
--   they contain.
--   
--   The functions <a>builderGetObject</a> and <a>builderGetObjects</a> can
--   be used to access the widgets in the interface by the names assigned
--   to them inside the UI description. Toplevel windows returned by these
--   functions will stay around until the user explicitly destroys them
--   with <a>windowDestroy</a>. Other widgets will either be part of a
--   larger hierarchy constructed by the builder (in which case you should
--   not have to worry about their lifecycle), or without a parent, in
--   which case they have to be added to some container to make use of
--   them. Non-widget objects need to be reffed with <a>objectRef</a> to
--   keep them beyond the lifespan of the builder.
--   
--   <h2>GtkBuilder UI Definitions</h2>
--   
--   <tt>GtkBuilder</tt> parses textual descriptions of user interfaces
--   which are specified in XML format. We refer to these descriptions as
--   “GtkBuilder UI definitions” or just “UI definitions” if the context is
--   clear.
--   
--   <h3>Structure of UI definitions</h3>
--   
--   UI definition files are always encoded in UTF-8.
--   
--   The toplevel element is <tt>&lt;interface&gt;</tt>. It optionally
--   takes a “domain” attribute, which will make the builder look for
--   translated strings using <tt>dgettext()</tt> in the domain specified.
--   This can also be done by calling <a>builderSetTranslationDomain</a> on
--   the builder. For example:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;?xml version="1.0" encoding="UTF-8"?&gt;
--   &lt;interface domain="your-app"&gt;
--     ...
--   &lt;/interface&gt;
--   </pre>
--   
--   <h3>Requirements</h3>
--   
--   The target toolkit version(s) are described by
--   <tt>&lt;requires&gt;</tt> elements, the “lib” attribute specifies the
--   widget library in question (currently the only supported value is
--   “gtk”) and the “version” attribute specifies the target version in the
--   form “<tt>&lt;major&gt;</tt>.<tt>&lt;minor&gt;</tt>”.
--   <tt>GtkBuilder</tt> will error out if the version requirements are not
--   met. For example:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;?xml version="1.0" encoding="UTF-8"?&gt;
--   &lt;interface domain="your-app"&gt;
--     &lt;requires lib="gtk" version="4.0" /&gt;
--   &lt;/interface&gt;
--   </pre>
--   
--   <h3>Objects</h3>
--   
--   Objects are defined as children of the <tt>&lt;interface&gt;</tt>
--   element.
--   
--   Objects are described by <tt>&lt;object&gt;</tt> elements, which can
--   contain <tt>&lt;property&gt;</tt> elements to set properties,
--   <tt>&lt;signal&gt;</tt> elements which connect signals to handlers,
--   and <tt>&lt;child&gt;</tt> elements, which describe child objects.
--   
--   Typically, the specific kind of object represented by an
--   <tt>&lt;object&gt;</tt> element is specified by the “class” attribute.
--   If the type has not been loaded yet, GTK tries to find the
--   <tt>get_type()</tt> function from the class name by applying
--   heuristics. This works in most cases, but if necessary, it is possible
--   to specify the name of the <tt>get_type()</tt> function explicitly
--   with the "type-func" attribute. If your UI definition is referencing
--   internal types, you should make sure to call <tt>g_type_ensure()</tt>
--   for each object type before parsing the UI definition.
--   
--   Objects may be given a name with the “id” attribute, which allows the
--   application to retrieve them from the builder with
--   <a>builderGetObject</a>. An id is also necessary to use the object as
--   property value in other parts of the UI definition. GTK reserves ids
--   starting and ending with <tt>___</tt> (three consecutive underscores)
--   for its own purposes.
--   
--   <h3>Properties</h3>
--   
--   Setting properties of objects is pretty straightforward with the
--   <tt>&lt;property&gt;</tt> element: the “name” attribute specifies the
--   name of the property, and the content of the element specifies the
--   value:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkButton"&gt;
--     &lt;property name="label"&gt;Hello, world&lt;/property&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   If the “translatable” attribute is set to a true value, GTK uses
--   <tt>gettext()</tt> (or <tt>dgettext()</tt> if the builder has a
--   translation domain set) to find a translation for the value. This
--   happens before the value is parsed, so it can be used for properties
--   of any type, but it is probably most useful for string properties. It
--   is also possible to specify a context to disambiguate short strings,
--   and comments which may help the translators:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkButton"&gt;
--     &lt;property name="label"
--               translatable="yes"
--               context="button"
--               comments="A classic"&gt;Hello, world&lt;/property&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   The xgettext tool that is part of gettext can extract these strings,
--   but note that it only looks for translatable="yes".
--   
--   <tt>GtkBuilder</tt> can parse textual representations for the most
--   common property types:
--   
--   <ul>
--   <li>characters</li>
--   <li>strings</li>
--   <li>integers</li>
--   <li>floating-point numbers</li>
--   <li>booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are
--   interpreted as true values, strings like “FALSE”, “f”, “no”, “n”, “0”
--   are interpreted as false values)</li>
--   <li>string lists (separated by newlines)</li>
--   <li>enumeration types (can be specified by their full C identifier
--   their short name used when registering the enumeration type, or their
--   integer value)</li>
--   <li>flag types (can be specified by their C identifier or short name,
--   optionally combined with “|” for bitwise OR, or a single integer value
--   e.g., “GTK_INPUT_HINT_EMOJI|GTK_INPUT_HINT_LOWERCASE”, or
--   “emoji|lowercase” or 520).</li>
--   <li>colors (in the format understood by <a>rGBAParse</a>)</li>
--   <li>transforms (in the format understood by
--   <a>transformParse</a>)</li>
--   <li>Pango attribute lists (in the format understood by
--   <a>attrListToString</a>)</li>
--   <li>Pango tab arrays (in the format understood by
--   <a>tabArrayToString</a>)</li>
--   <li>Pango font descriptions (in the format understood by
--   <a>fontDescriptionFromString</a>)</li>
--   <li><tt>GVariant</tt> (in the format understood by
--   <a>variantParse</a>)</li>
--   <li>textures (can be specified as an object id, a resource path or a
--   filename of an image file to load relative to the Builder file or the
--   CWD if <a>builderAddFromString</a> was used)</li>
--   <li>GFile (like textures, can be specified as an object id, a URI or a
--   filename of a file to load relative to the Builder file or the CWD if
--   <a>builderAddFromString</a> was used)</li>
--   </ul>
--   
--   Objects can be referred to by their name and by default refer to
--   objects declared in the local XML fragment and objects exposed via
--   <a>builderExposeObject</a>. In general, <tt>GtkBuilder</tt> allows
--   forward references to objects declared in the local XML; an object
--   doesn’t have to be constructed before it can be referred to. The
--   exception to this rule is that an object has to be constructed before
--   it can be used as the value of a construct-only property.
--   
--   <h3>Child objects</h3>
--   
--   Many widgets have properties for child widgets, such as
--   <a>Expander:child</a>. In this case, the preferred way to specify the
--   child widget in a ui file is to simply set the property:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkExpander"&gt;
--     &lt;property name="child"&gt;
--       &lt;object class="GtkLabel"&gt;
--       ...
--       &lt;/object&gt;
--     &lt;/property&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   Generic containers that can contain an arbitrary number of children,
--   such as <a>Box</a> instead use the <tt>&lt;child&gt;</tt> element. A
--   <tt>&lt;child&gt;</tt> element contains an <tt>&lt;object&gt;</tt>
--   element which describes the child object. Most often, child objects
--   are widgets inside a container, but they can also be, e.g., actions in
--   an action group, or columns in a tree model.
--   
--   Any object type that implements the <a>Buildable</a> interface can
--   specify how children may be added to it. Since many objects and
--   widgets that are included with GTK already implement the
--   <tt>GtkBuildable</tt> interface, typically child objects can be added
--   using the <tt>&lt;child&gt;</tt> element without having to be
--   concerned about the underlying implementation.
--   
--   See the <a>`GtkWidget` documentation</a> for many examples of using
--   <tt>GtkBuilder</tt> with widgets, including setting child objects
--   using the <tt>&lt;child&gt;</tt> element.
--   
--   A noteworthy special case to the general rule that only objects
--   implementing <tt>GtkBuildable</tt> may specify how to handle the
--   <tt>&lt;child&gt;</tt> element is that <tt>GtkBuilder</tt> provides
--   special support for adding objects to a <a>ListStore</a> by using the
--   <tt>&lt;child&gt;</tt> element. For instance:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GListStore"&gt;
--     &lt;property name="item-type"&gt;MyObject&lt;/property&gt;
--     &lt;child&gt;
--       &lt;object class="MyObject" /&gt;
--     &lt;/child&gt;
--     ...
--   &lt;/object&gt;
--   </pre>
--   
--   <h3>Property bindings</h3>
--   
--   It is also possible to bind a property value to another object's
--   property value using the attributes "bind-source" to specify the
--   source object of the binding, and optionally, "bind-property" and
--   "bind-flags" to specify the source property and source binding flags
--   respectively. Internally, <tt>GtkBuilder</tt> implements this using
--   <a>Binding</a> objects.
--   
--   For instance, in the example below the “label” property of the
--   <tt>bottom_label</tt> widget is bound to the “label” property of the
--   <tt>top_button</tt> widget:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkBox"&gt;
--     &lt;property name="orientation"&gt;vertical&lt;/property&gt;
--     &lt;child&gt;
--       &lt;object class="GtkButton" id="top_button"&gt;
--         &lt;property name="label"&gt;Hello, world&lt;/property&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;child&gt;
--       &lt;object class="GtkLabel" id="bottom_label"&gt;
--         &lt;property name="label"
--                   bind-source="top_button"
--                   bind-property="label"
--                   bind-flags="sync-create" /&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   For more information, see the documentation of the
--   <a>objectBindProperty</a> method.
--   
--   Please note that another way to set up bindings between objects in .ui
--   files is to use the <tt>GtkExpression</tt> methodology. See the
--   <a>`GtkExpression` documentation</a> for more information.
--   
--   <h3>Internal children</h3>
--   
--   Sometimes it is necessary to refer to widgets which have implicitly
--   been constructed by GTK as part of a composite widget, to set
--   properties on them or to add further children (e.g. the content area
--   of a <tt>GtkDialog</tt>). This can be achieved by setting the
--   “internal-child” property of the <tt>&lt;child&gt;</tt> element to a
--   true value. Note that <tt>GtkBuilder</tt> still requires an
--   <tt>&lt;object&gt;</tt> element for the internal child, even if it has
--   already been constructed.
--   
--   <h3>Specialized children</h3>
--   
--   A number of widgets have different places where a child can be added
--   (e.g. tabs vs. page content in notebooks). This can be reflected in a
--   UI definition by specifying the “type” attribute on a
--   <tt>&lt;child&gt;</tt> The possible values for the “type” attribute
--   are described in the sections describing the widget-specific portions
--   of UI definitions.
--   
--   <h3>Signal handlers and function pointers</h3>
--   
--   Signal handlers are set up with the <tt>&lt;signal&gt;</tt> element.
--   The “name” attribute specifies the name of the signal, and the
--   “handler” attribute specifies the function to connect to the signal.
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkButton" id="hello_button"&gt;
--     &lt;signal name="clicked" handler="hello_button__clicked" /&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   The remaining attributes, “after”, “swapped” and “object”, have the
--   same meaning as the corresponding parameters of the
--   <tt><i>GObject.signal_connect_object</i></tt> or
--   <tt><i>GObject.signal_connect_data</i></tt> functions:
--   
--   <ul>
--   <li>“after” matches the <tt>G_CONNECT_AFTER</tt> flag, and will ensure
--   that the handler is called after the default class closure for the
--   signal</li>
--   <li>“swapped” matches the <tt>G_CONNECT_SWAPPED</tt> flag, and will
--   swap the instance and closure arguments when invoking the signal
--   handler</li>
--   <li>“object” will bind the signal handler to the lifetime of the
--   object referenced by the attribute</li>
--   </ul>
--   
--   By default "swapped" will be set to "yes" if not specified otherwise,
--   in the case where "object" is set, for convenience. A
--   “last_modification_time” attribute is also allowed, but it does not
--   have a meaning to the builder.
--   
--   When compiling applications for Windows, you must declare signal
--   callbacks with the <tt>G_MODULE_EXPORT</tt> decorator, or they will
--   not be put in the symbol table:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   G_MODULE_EXPORT void
--   hello_button__clicked (GtkButton *button,
--                          gpointer data)
--   {
--     // ...
--   }
--   </pre>
--   
--   On Linux and Unix, this is not necessary; applications should instead
--   be compiled with the <tt>-Wl,--export-dynamic</tt> argument inside
--   their compiler flags, and linked against <tt>gmodule-export-2.0</tt>.
--   
--   <h2>Example UI Definition</h2>
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;interface&gt;
--     &lt;object class="GtkDialog" id="dialog1"&gt;
--       &lt;child internal-child="content_area"&gt;
--         &lt;object class="GtkBox"&gt;
--           &lt;child internal-child="action_area"&gt;
--             &lt;object class="GtkBox"&gt;
--               &lt;child&gt;
--                 &lt;object class="GtkButton" id="ok_button"&gt;
--                   &lt;property name="label" translatable="yes"&gt;_Ok&lt;/property&gt;
--                   &lt;property name="use-underline"&gt;True&lt;/property&gt;
--                   &lt;signal name="clicked" handler="ok_button_clicked"/&gt;
--                 &lt;/object&gt;
--               &lt;/child&gt;
--             &lt;/object&gt;
--           &lt;/child&gt;
--         &lt;/object&gt;
--       &lt;/child&gt;
--     &lt;/object&gt;
--   &lt;/interface&gt;
--   </pre>
--   
--   <h2>Using GtkBuildable for extending UI definitions</h2>
--   
--   Objects can implement the <a>Buildable</a> interface to add custom
--   elements and attributes to the XML. Typically, any extension will be
--   documented in each type that implements the interface.
--   
--   <h2>Menus</h2>
--   
--   In addition to objects with properties that are created with
--   <tt>&lt;object&gt;</tt> and <tt>&lt;property&gt;</tt> elements,
--   <tt>GtkBuilder</tt> also allows to parse XML menu definitions as used
--   by <a>Menu</a> when exporting menu models over D-Bus, and as described
--   in the <a>PopoverMenu</a> documentation. Menus can be defined as
--   toplevel elements, or as property values for properties of type
--   <tt>GMenuModel</tt>.
--   
--   <h2>Templates</h2>
--   
--   When describing a <a>Widget</a>, you can use the
--   <tt>&lt;template&gt;</tt> tag to describe a UI bound to a specific
--   widget type. GTK will automatically load the UI definition when
--   instantiating the type, and bind children and signal handlers to
--   instance fields and function symbols.
--   
--   For more information, see the <a>`GtkWidget` documentation</a> for
--   details.
module GI.Gtk.Objects.Builder

-- | Memory-managed wrapper type.
newtype Builder
Builder :: ManagedPtr Builder -> Builder

-- | Type class for types which can be safely cast to <a>Builder</a>, for
--   instance with <a>toBuilder</a>.
class (GObject o, IsDescendantOf Builder o) => IsBuilder o

-- | Cast to <a>Builder</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toBuilder :: (MonadIO m, IsBuilder o) => o -> m Builder

-- | Parses a file containing a UI definition and merges it with the
--   current contents of <i><tt>builder</tt></i>.
--   
--   This function is useful if you need to call
--   <a>builderSetCurrentObject</a>) to add user data to callbacks before
--   loading GtkBuilder UI. Otherwise, you probably want
--   <a>builderNewFromFile</a> instead.
--   
--   If an error occurs, 0 will be returned and <i><tt>error</tt></i> will
--   be assigned a <tt>GError</tt> from the <tt>GTK_BUILDER_ERROR</tt>,
--   <tt>G_MARKUP_ERROR</tt> or <tt>G_FILE_ERROR</tt> domains.
--   
--   It’s not really reasonable to attempt to handle failures of this call.
--   You should not use this function with untrusted files (ie: files that
--   are not part of your application). Broken <tt>GtkBuilder</tt> files
--   can easily crash your program, and it’s possible that memory was
--   leaked leading up to the reported failure. The only reasonable thing
--   to do when an error is detected is to call <tt>g_error()</tt>.
builderAddFromFile :: (HasCallStack, MonadIO m, IsBuilder a) => a -> [Char] -> m ()

-- | Parses a resource file containing a UI definition and merges it with
--   the current contents of <i><tt>builder</tt></i>.
--   
--   This function is useful if you need to call
--   <a>builderSetCurrentObject</a> to add user data to callbacks before
--   loading GtkBuilder UI. Otherwise, you probably want
--   <a>builderNewFromResource</a> instead.
--   
--   If an error occurs, 0 will be returned and <i><tt>error</tt></i> will
--   be assigned a <tt>GError</tt> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt>, <tt><i>G_MARKUP_ERROR</i></tt> or
--   <tt><i>G_RESOURCE_ERROR</i></tt> domain.
--   
--   It’s not really reasonable to attempt to handle failures of this call.
--   The only reasonable thing to do when an error is detected is to call
--   <tt><i>g_error()</i></tt>.
builderAddFromResource :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m ()

-- | Parses a string containing a UI definition and merges it with the
--   current contents of <i><tt>builder</tt></i>.
--   
--   This function is useful if you need to call
--   <a>builderSetCurrentObject</a> to add user data to callbacks before
--   loading <tt>GtkBuilder</tt> UI. Otherwise, you probably want
--   <a>builderNewFromString</a> instead.
--   
--   Upon errors <a>False</a> will be returned and <i><tt>error</tt></i>
--   will be assigned a <tt>GError</tt> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt>, <tt><i>G_MARKUP_ERROR</i></tt> or
--   <tt><i>G_VARIANT_PARSE_ERROR</i></tt> domain.
--   
--   It’s not really reasonable to attempt to handle failures of this call.
--   The only reasonable thing to do when an error is detected is to call
--   <tt><i>g_error()</i></tt>.
builderAddFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> Int64 -> m ()

-- | Parses a file containing a UI definition building only the requested
--   objects and merges them with the current contents of
--   <i><tt>builder</tt></i>.
--   
--   Upon errors, 0 will be returned and <i><tt>error</tt></i> will be
--   assigned a <tt>GError</tt> from the <tt><i>GTK_BUILDER_ERROR</i></tt>,
--   <tt><i>G_MARKUP_ERROR</i></tt> or <tt><i>G_FILE_ERROR</i></tt> domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a <tt>GtkTreeView</tt> that depends on its
--   <tt>GtkTreeModel</tt>), you have to explicitly list all of them in
--   <i><tt>objectIds</tt></i>.
builderAddObjectsFromFile :: (HasCallStack, MonadIO m, IsBuilder a) => a -> [Char] -> [Text] -> m ()

-- | Parses a resource file containing a UI definition, building only the
--   requested objects and merges them with the current contents of
--   <i><tt>builder</tt></i>.
--   
--   Upon errors, 0 will be returned and <i><tt>error</tt></i> will be
--   assigned a <tt>GError</tt> from the <tt><i>GTK_BUILDER_ERROR</i></tt>,
--   <tt><i>G_MARKUP_ERROR</i></tt> or <tt><i>G_RESOURCE_ERROR</i></tt>
--   domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a <tt>GtkTreeView</tt> that depends on its
--   <tt>GtkTreeModel</tt>), you have to explicitly list all of them in
--   <i><tt>objectIds</tt></i>.
builderAddObjectsFromResource :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> [Text] -> m ()

-- | Parses a string containing a UI definition, building only the
--   requested objects and merges them with the current contents of
--   <i><tt>builder</tt></i>.
--   
--   Upon errors <a>False</a> will be returned and <i><tt>error</tt></i>
--   will be assigned a <tt>GError</tt> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt> or <tt><i>G_MARKUP_ERROR</i></tt>
--   domain.
--   
--   If you are adding an object that depends on an object that is not its
--   child (for instance a <tt>GtkTreeView</tt> that depends on its
--   <tt>GtkTreeModel</tt>), you have to explicitly list all of them in
--   <i><tt>objectIds</tt></i>.
builderAddObjectsFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> Int64 -> [Text] -> m ()

-- | Creates a closure to invoke the function called
--   <i><tt>functionName</tt></i>.
--   
--   This is using the <tt><i>create_closure()</i></tt> implementation of
--   <i><tt>builder</tt></i>'s <a>BuilderScope</a>.
--   
--   If no closure could be created, <a>Nothing</a> will be returned and
--   <i><tt>error</tt></i> will be set.
builderCreateClosure :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b) => a -> Text -> [BuilderClosureFlags] -> Maybe b -> m (Maybe (GClosure c))

-- | Add <i><tt>object</tt></i> to the <i><tt>builder</tt></i> object pool
--   so it can be referenced just like any other object built by builder.
--   
--   Only a single object may be added using <i><tt>name</tt></i>. However,
--   it is not an error to expose the same object under multiple names.
--   <tt>gtk_builder_get_object()</tt> may be used to determine if an
--   object has already been added with <i><tt>name</tt></i>.
builderExposeObject :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b) => a -> Text -> b -> m ()

-- | Main private entry point for building composite components from
--   template XML.
--   
--   Most likely you do not need to call this function in applications as
--   templates are handled by <tt>GtkWidget</tt>.
builderExtendWithTemplate :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b) => a -> b -> GType -> Text -> Int64 -> m ()

-- | Gets the current object set via <a>builderSetCurrentObject</a>.
builderGetCurrentObject :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m (Maybe Object)

-- | Gets the object named <i><tt>name</tt></i>.
--   
--   Note that this function does not increment the reference count of the
--   returned object.
builderGetObject :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m (Maybe Object)

-- | Gets all objects that have been constructed by
--   <i><tt>builder</tt></i>.
--   
--   Note that this function does not increment the reference counts of the
--   returned objects.
builderGetObjects :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m [Object]

-- | Gets the scope in use that was set via <a>builderSetScope</a>.
builderGetScope :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m BuilderScope

-- | Gets the translation domain of <i><tt>builder</tt></i>.
builderGetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> m (Maybe Text)

-- | Looks up a type by name.
--   
--   This is using the virtual function that <tt>GtkBuilder</tt> has for
--   that purpose. This is mainly used when implementing the
--   <tt>GtkBuildable</tt> interface on a type.
builderGetTypeFromName :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Text -> m GType

-- | Creates a new empty builder object.
--   
--   This function is only useful if you intend to make multiple calls to
--   <a>builderAddFromFile</a>, <a>builderAddFromResource</a> or
--   <a>builderAddFromString</a> in order to merge multiple UI descriptions
--   into a single builder.
builderNew :: (HasCallStack, MonadIO m) => m Builder

-- | Parses the UI definition in the file <i><tt>filename</tt></i>.
--   
--   If there is an error opening the file or parsing the description then
--   the program will be aborted. You should only ever attempt to parse
--   user interface descriptions that are shipped as part of your program.
builderNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m Builder

-- | Parses the UI definition at <i><tt>resourcePath</tt></i>.
--   
--   If there is an error locating the resource or parsing the description,
--   then the program will be aborted.
builderNewFromResource :: (HasCallStack, MonadIO m) => Text -> m Builder

-- | Parses the UI definition in <i><tt>string</tt></i>.
--   
--   If <i><tt>string</tt></i> is <a>Nothing</a>-terminated, then
--   <i><tt>length</tt></i> should be -1. If <i><tt>length</tt></i> is not
--   -1, then it is the length of <i><tt>string</tt></i>.
--   
--   If there is an error parsing <i><tt>string</tt></i> then the program
--   will be aborted. You should not attempt to parse user interface
--   description from untrusted sources.
builderNewFromString :: (HasCallStack, MonadIO m) => Text -> Int64 -> m Builder

-- | Sets the current object for the <i><tt>builder</tt></i>.
--   
--   The current object can be thought of as the <tt>this</tt> object that
--   the builder is working for and will often be used as the default
--   object when an object is optional.
--   
--   <a>widgetInitTemplate</a> for example will set the current object to
--   the widget the template is inited for. For functions like
--   <a>builderNewFromResource</a>, the current object will be
--   <a>Nothing</a>.
builderSetCurrentObject :: (HasCallStack, MonadIO m, IsBuilder a, IsObject b) => a -> Maybe b -> m ()

-- | Sets the scope the builder should operate in.
--   
--   If <i><tt>scope</tt></i> is <a>Nothing</a>, a new <a>BuilderCScope</a>
--   will be created.
builderSetScope :: (HasCallStack, MonadIO m, IsBuilder a, IsBuilderScope b) => a -> Maybe b -> m ()

-- | Sets the translation domain of <i><tt>builder</tt></i>.
builderSetTranslationDomain :: (HasCallStack, MonadIO m, IsBuilder a) => a -> Maybe Text -> m ()

-- | Demarshals a value from a string.
--   
--   This function calls <a>valueInit</a> on the <i><tt>value</tt></i>
--   argument, so it need not be initialised beforehand.
--   
--   Can handle char, uchar, boolean, int, uint, long, ulong, enum, flags,
--   float, double, string, <tt>GdkRGBA</tt> and <tt>GtkAdjustment</tt>
--   type values.
--   
--   Upon errors <a>False</a> will be returned and <i><tt>error</tt></i>
--   will be assigned a <tt>GError</tt> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt> domain.
builderValueFromString :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GParamSpec -> Text -> m GValue

-- | Demarshals a value from a string.
--   
--   Unlike <a>builderValueFromString</a>, this function takes a
--   <tt>GType</tt> instead of <tt>GParamSpec</tt>.
--   
--   Calls <a>valueInit</a> on the <i><tt>value</tt></i> argument, so it
--   need not be initialised beforehand.
--   
--   Upon errors <a>False</a> will be returned and <i><tt>error</tt></i>
--   will be assigned a <tt>GError</tt> from the
--   <tt><i>GTK_BUILDER_ERROR</i></tt> domain.
builderValueFromStringType :: (HasCallStack, MonadIO m, IsBuilder a) => a -> GType -> Text -> m GValue

-- | Set the value of the “<tt>current-object</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #currentObject
--   </pre>
clearBuilderCurrentObject :: (MonadIO m, IsBuilder o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-object</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBuilderCurrentObject :: (IsBuilder o, MonadIO m, IsObject a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>current-object</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> builder #currentObject
--   </pre>
getBuilderCurrentObject :: (MonadIO m, IsBuilder o) => o -> m (Maybe Object)

-- | Set the value of the “<tt>current-object</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> builder [ #currentObject <a>:=</a> value ]
--   </pre>
setBuilderCurrentObject :: (MonadIO m, IsBuilder o, IsObject a) => o -> a -> m ()

-- | Set the value of the “<tt>scope</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #scope
--   </pre>
clearBuilderScope :: (MonadIO m, IsBuilder o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scope</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBuilderScope :: (IsBuilder o, MonadIO m, IsBuilderScope a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>scope</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> builder #scope
--   </pre>
getBuilderScope :: (MonadIO m, IsBuilder o) => o -> m BuilderScope

-- | Set the value of the “<tt>scope</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> builder [ #scope <a>:=</a> value ]
--   </pre>
setBuilderScope :: (MonadIO m, IsBuilder o, IsBuilderScope a) => o -> a -> m ()

-- | Set the value of the “<tt>translation-domain</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #translationDomain
--   </pre>
clearBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>translation-domain</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructBuilderTranslationDomain :: (IsBuilder o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>translation-domain</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> builder #translationDomain
--   </pre>
getBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>translation-domain</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> builder [ #translationDomain <a>:=</a> value ]
--   </pre>
setBuilderTranslationDomain :: (MonadIO m, IsBuilder o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Builder.Builder
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Builder.Builder
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Builder.Builder
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Builder.Builder o) => GI.Gtk.Objects.Builder.IsBuilder o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Builder.Builder)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Builder.Builder
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Builder.Builder


-- | A <tt>GtkBuilderScope</tt> implementation for the C language.
--   
--   <tt>GtkBuilderCScope</tt> instances use symbols explicitly added to
--   <i><tt>builder</tt></i> with prior calls to
--   <a>builderCScopeAddCallbackSymbol</a>. If developers want to do that,
--   they are encouraged to create their own scopes for that purpose.
--   
--   In the case that symbols are not explicitly added; GTK will uses
--   <tt>GModule</tt>’s introspective features (by opening the module
--   <a>Nothing</a>) to look at the application’s symbol table. From here
--   it tries to match the signal function names given in the interface
--   description with symbols in the application.
--   
--   Note that unless <a>builderCScopeAddCallbackSymbol</a> is called for
--   all signal callbacks which are referenced by the loaded XML, this
--   functionality will require that <tt>GModule</tt> be supported on the
--   platform.
module GI.Gtk.Objects.BuilderCScope

-- | Memory-managed wrapper type.
newtype BuilderCScope
BuilderCScope :: ManagedPtr BuilderCScope -> BuilderCScope

-- | Type class for types which can be safely cast to <a>BuilderCScope</a>,
--   for instance with <a>toBuilderCScope</a>.
class (GObject o, IsDescendantOf BuilderCScope o) => IsBuilderCScope o

-- | Cast to <a>BuilderCScope</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBuilderCScope :: (MonadIO m, IsBuilderCScope o) => o -> m BuilderCScope

-- | Adds the <i><tt>callbackSymbol</tt></i> to the scope of
--   <i><tt>builder</tt></i> under the given <i><tt>callbackName</tt></i>.
--   
--   Using this function overrides the behavior of
--   <a>builderCreateClosure</a> for any callback symbols that are added.
--   Using this method allows for better encapsulation as it does not
--   require that callback symbols be declared in the global namespace.
builderCScopeAddCallbackSymbol :: (HasCallStack, MonadIO m, IsBuilderCScope a) => a -> Text -> Callback -> m ()

-- | Creates a new <tt>GtkBuilderCScope</tt> object to use with future
--   <tt>GtkBuilder</tt> instances.
--   
--   Calling this function is only necessary if you want to add custom
--   callbacks via <a>builderCScopeAddCallbackSymbol</a>.
builderCScopeNew :: (HasCallStack, MonadIO m) => m BuilderCScope
instance GHC.Classes.Eq GI.Gtk.Objects.BuilderCScope.BuilderCScope
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.BuilderCScope.BuilderCScope
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.BuilderCScope.BuilderCScope
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.BuilderCScope.BuilderCScope o) => GI.Gtk.Objects.BuilderCScope.IsBuilderCScope o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.BuilderCScope.BuilderCScope)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.BuilderCScope.BuilderCScope
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.BuilderCScope.BuilderCScope


-- | Configures how rows are displayed in a <a>ColumnView</a>.
--   
--   It is not used to set the widgets displayed in the individual cells.
--   For that see [method<i><tt>gtkColumnViewColumn</tt></i>.set_factory]
--   and [class<i><tt>gtkColumnViewCell</tt></i>].
--   
--   <i>Since: 4.12</i>
module GI.Gtk.Objects.ColumnViewRow

-- | Memory-managed wrapper type.
newtype ColumnViewRow
ColumnViewRow :: ManagedPtr ColumnViewRow -> ColumnViewRow

-- | Type class for types which can be safely cast to <a>ColumnViewRow</a>,
--   for instance with <a>toColumnViewRow</a>.
class (GObject o, IsDescendantOf ColumnViewRow o) => IsColumnViewRow o

-- | Cast to <a>ColumnViewRow</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColumnViewRow :: (MonadIO m, IsColumnViewRow o) => o -> m ColumnViewRow

-- | Gets the accessible description of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.12</i>
columnViewRowGetAccessibleDescription :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m Text

-- | Gets the accessible label of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.12</i>
columnViewRowGetAccessibleLabel :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m Text

-- | Checks if the row has been set to be activatable via
--   <a>columnViewRowSetActivatable</a>.
--   
--   <i>Since: 4.12</i>
columnViewRowGetActivatable :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m Bool

-- | Checks if a row item has been set to be focusable via
--   <a>columnViewRowSetFocusable</a>.
--   
--   <i>Since: 4.12</i>
columnViewRowGetFocusable :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m Bool

-- | Gets the model item that associated with <i><tt>self</tt></i>.
--   
--   If <i><tt>self</tt></i> is unbound, this function returns
--   <a>Nothing</a>.
--   
--   <i>Since: 4.12</i>
columnViewRowGetItem :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m (Maybe Object)

-- | Gets the position in the model that <i><tt>self</tt></i> currently
--   displays.
--   
--   If <i><tt>self</tt></i> is unbound, <a>INVALID_LIST_POSITION</a> is
--   returned.
--   
--   <i>Since: 4.12</i>
columnViewRowGetPosition :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m Word32

-- | Checks if the row has been set to be selectable via
--   <a>columnViewRowSetSelectable</a>.
--   
--   Do not confuse this function with <a>columnViewRowGetSelected</a>.
--   
--   <i>Since: 4.12</i>
columnViewRowGetSelectable :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m Bool

-- | Checks if the item is selected that this row corresponds to.
--   
--   The selected state is maintained by the list widget and its model and
--   cannot be set otherwise.
--   
--   <i>Since: 4.12</i>
columnViewRowGetSelected :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> m Bool

-- | Sets the accessible description for the row, which may be used by e.g.
--   screen readers.
--   
--   <i>Since: 4.12</i>
columnViewRowSetAccessibleDescription :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> Text -> m ()

-- | Sets the accessible label for the row, which may be used by e.g.
--   screen readers.
--   
--   <i>Since: 4.12</i>
columnViewRowSetAccessibleLabel :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> Text -> m ()

-- | Sets <i><tt>self</tt></i> to be activatable.
--   
--   If a row is activatable, double-clicking on the row, using the Return
--   key or calling <a>widgetActivate</a> will activate the row. Activating
--   instructs the containing columnview to emit the
--   <a>ColumnView::activate</a> signal.
--   
--   By default, row are activatable.
--   
--   <i>Since: 4.12</i>
columnViewRowSetActivatable :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> Bool -> m ()

-- | Sets <i><tt>self</tt></i> to be focusable.
--   
--   If a row is focusable, it can be focused using the keyboard. This
--   works similar to <a>widgetSetFocusable</a>.
--   
--   Note that if row are not focusable, the contents of cells can still be
--   focused if they are focusable.
--   
--   By default, rows are focusable.
--   
--   <i>Since: 4.12</i>
columnViewRowSetFocusable :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> Bool -> m ()

-- | Sets <i><tt>self</tt></i> to be selectable.
--   
--   If a row is selectable, clicking on the row or using the keyboard will
--   try to select or unselect the row. Whether this succeeds is up to the
--   model to determine, as it is managing the selected state.
--   
--   Note that this means that making a row non-selectable has no influence
--   on the selected state at all. A non-selectable row may still be
--   selected.
--   
--   By default, rows are selectable.
--   
--   <i>Since: 4.12</i>
columnViewRowSetSelectable :: (HasCallStack, MonadIO m, IsColumnViewRow a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accessible-description</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructColumnViewRowAccessibleDescription :: (IsColumnViewRow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accessible-description</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #accessibleDescription
--   </pre>
getColumnViewRowAccessibleDescription :: (MonadIO m, IsColumnViewRow o) => o -> m Text

-- | Set the value of the “<tt>accessible-description</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewRow [ #accessibleDescription <a>:=</a> value ]
--   </pre>
setColumnViewRowAccessibleDescription :: (MonadIO m, IsColumnViewRow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accessible-label</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructColumnViewRowAccessibleLabel :: (IsColumnViewRow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accessible-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #accessibleLabel
--   </pre>
getColumnViewRowAccessibleLabel :: (MonadIO m, IsColumnViewRow o) => o -> m Text

-- | Set the value of the “<tt>accessible-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewRow [ #accessibleLabel <a>:=</a> value ]
--   </pre>
setColumnViewRowAccessibleLabel :: (MonadIO m, IsColumnViewRow o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activatable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColumnViewRowActivatable :: (IsColumnViewRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #activatable
--   </pre>
getColumnViewRowActivatable :: (MonadIO m, IsColumnViewRow o) => o -> m Bool

-- | Set the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewRow [ #activatable <a>:=</a> value ]
--   </pre>
setColumnViewRowActivatable :: (MonadIO m, IsColumnViewRow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focusable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColumnViewRowFocusable :: (IsColumnViewRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #focusable
--   </pre>
getColumnViewRowFocusable :: (MonadIO m, IsColumnViewRow o) => o -> m Bool

-- | Set the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewRow [ #focusable <a>:=</a> value ]
--   </pre>
setColumnViewRowFocusable :: (MonadIO m, IsColumnViewRow o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #item
--   </pre>
getColumnViewRowItem :: (MonadIO m, IsColumnViewRow o) => o -> m (Maybe Object)

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #position
--   </pre>
getColumnViewRowPosition :: (MonadIO m, IsColumnViewRow o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selectable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColumnViewRowSelectable :: (IsColumnViewRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #selectable
--   </pre>
getColumnViewRowSelectable :: (MonadIO m, IsColumnViewRow o) => o -> m Bool

-- | Set the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewRow [ #selectable <a>:=</a> value ]
--   </pre>
setColumnViewRowSelectable :: (MonadIO m, IsColumnViewRow o) => o -> Bool -> m ()

-- | Get the value of the “<tt>selected</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewRow #selected
--   </pre>
getColumnViewRowSelected :: (MonadIO m, IsColumnViewRow o) => o -> m Bool
instance GHC.Classes.Eq GI.Gtk.Objects.ColumnViewRow.ColumnViewRow
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColumnViewRow.ColumnViewRow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColumnViewRow.ColumnViewRow
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColumnViewRow.ColumnViewRow o) => GI.Gtk.Objects.ColumnViewRow.IsColumnViewRow o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColumnViewRow.ColumnViewRow)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColumnViewRow.ColumnViewRow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColumnViewRow.ColumnViewRow


-- | Describes a constraint between attributes of two widgets, expressed as
--   a linear equation.
--   
--   The typical equation for a constraint is:
--   
--   <pre>
--   target.target_attr = source.source_attr × multiplier + constant
--   </pre>
--   
--   Each <tt>GtkConstraint</tt> is part of a system that will be solved by
--   a <a>ConstraintLayout</a> in order to allocate and position each child
--   widget or guide.
--   
--   The source and target, as well as their attributes, of a
--   <tt>GtkConstraint</tt> instance are immutable after creation.
module GI.Gtk.Objects.Constraint

-- | Memory-managed wrapper type.
newtype Constraint
Constraint :: ManagedPtr Constraint -> Constraint

-- | Type class for types which can be safely cast to <a>Constraint</a>,
--   for instance with <a>toConstraint</a>.
class (GObject o, IsDescendantOf Constraint o) => IsConstraint o

-- | Cast to <a>Constraint</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toConstraint :: (MonadIO m, IsConstraint o) => o -> m Constraint

-- | Retrieves the constant factor added to the source attributes' value.
constraintGetConstant :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m Double

-- | Retrieves the multiplication factor applied to the source attribute's
--   value.
constraintGetMultiplier :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m Double

-- | The order relation between the terms of the constraint.
constraintGetRelation :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m ConstraintRelation

-- | Retrieves the <a>ConstraintTarget</a> used as the source for the
--   constraint.
--   
--   If the source is set to <tt>NULL</tt> at creation, the constraint will
--   use the widget using the <a>ConstraintLayout</a> as the source.
constraintGetSource :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m (Maybe ConstraintTarget)

-- | Retrieves the attribute of the source to be read by the constraint.
constraintGetSourceAttribute :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m ConstraintAttribute

-- | Retrieves the strength of the constraint.
constraintGetStrength :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m Int32

-- | Retrieves the <a>ConstraintTarget</a> used as the target for the
--   constraint.
--   
--   If the targe is set to <tt>NULL</tt> at creation, the constraint will
--   use the widget using the <a>ConstraintLayout</a> as the target.
constraintGetTarget :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m (Maybe ConstraintTarget)

-- | Retrieves the attribute of the target to be set by the constraint.
constraintGetTargetAttribute :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m ConstraintAttribute

-- | Checks whether the constraint is attached to a
--   <a>ConstraintLayout</a>, and it is contributing to the layout.
constraintIsAttached :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m Bool

-- | Checks whether the constraint describes a relation between an
--   attribute on the <a>Constraint:target</a> and a constant value.
constraintIsConstant :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m Bool

-- | Checks whether the constraint is a required relation for solving the
--   constraint layout.
constraintIsRequired :: (HasCallStack, MonadIO m, IsConstraint a) => a -> m Bool

-- | Creates a new constraint representing a relation between a layout
--   attribute on a source and a layout attribute on a target.
constraintNew :: (HasCallStack, MonadIO m, IsConstraintTarget a, IsConstraintTarget b) => Maybe a -> ConstraintAttribute -> ConstraintRelation -> Maybe b -> ConstraintAttribute -> Double -> Double -> Int32 -> m Constraint

-- | Creates a new constraint representing a relation between a layout
--   attribute on a target and a constant value.
constraintNewConstant :: (HasCallStack, MonadIO m, IsConstraintTarget a) => Maybe a -> ConstraintAttribute -> ConstraintRelation -> Double -> Int32 -> m Constraint

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>constant</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintConstant :: (IsConstraint o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>constant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #constant
--   </pre>
getConstraintConstant :: (MonadIO m, IsConstraint o) => o -> m Double

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>multiplier</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintMultiplier :: (IsConstraint o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>multiplier</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #multiplier
--   </pre>
getConstraintMultiplier :: (MonadIO m, IsConstraint o) => o -> m Double

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>relation</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintRelation :: (IsConstraint o, MonadIO m) => ConstraintRelation -> m (GValueConstruct o)

-- | Get the value of the “<tt>relation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #relation
--   </pre>
getConstraintRelation :: (MonadIO m, IsConstraint o) => o -> m ConstraintRelation

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>source</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructConstraintSource :: (IsConstraint o, MonadIO m, IsConstraintTarget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>source</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #source
--   </pre>
getConstraintSource :: (MonadIO m, IsConstraint o) => o -> m (Maybe ConstraintTarget)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>source-attribute</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructConstraintSourceAttribute :: (IsConstraint o, MonadIO m) => ConstraintAttribute -> m (GValueConstruct o)

-- | Get the value of the “<tt>source-attribute</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #sourceAttribute
--   </pre>
getConstraintSourceAttribute :: (MonadIO m, IsConstraint o) => o -> m ConstraintAttribute

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strength</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintStrength :: (IsConstraint o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>strength</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #strength
--   </pre>
getConstraintStrength :: (MonadIO m, IsConstraint o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>target</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructConstraintTarget :: (IsConstraint o, MonadIO m, IsConstraintTarget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #target
--   </pre>
getConstraintTarget :: (MonadIO m, IsConstraint o) => o -> m (Maybe ConstraintTarget)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>target-attribute</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructConstraintTargetAttribute :: (IsConstraint o, MonadIO m) => ConstraintAttribute -> m (GValueConstruct o)

-- | Get the value of the “<tt>target-attribute</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraint #targetAttribute
--   </pre>
getConstraintTargetAttribute :: (MonadIO m, IsConstraint o) => o -> m ConstraintAttribute
instance GHC.Classes.Eq GI.Gtk.Objects.Constraint.Constraint
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Constraint.Constraint
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Constraint.Constraint
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Constraint.Constraint o) => GI.Gtk.Objects.Constraint.IsConstraint o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Constraint.Constraint)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Constraint.Constraint
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Constraint.Constraint


-- | An invisible layout element in a <tt>GtkConstraintLayout</tt>.
--   
--   The <tt>GtkConstraintLayout</tt> treats guides like widgets. They can
--   be used as the source or target of a <tt>GtkConstraint</tt>.
--   
--   Guides have a minimum, maximum and natural size. Depending on the
--   constraints that are applied, they can act like a guideline that
--   widgets can be aligned to, or like *flexible space*.
--   
--   Unlike a <tt>GtkWidget</tt>, a <tt>GtkConstraintGuide</tt> will not be
--   drawn.
module GI.Gtk.Objects.ConstraintGuide

-- | Memory-managed wrapper type.
newtype ConstraintGuide
ConstraintGuide :: ManagedPtr ConstraintGuide -> ConstraintGuide

-- | Type class for types which can be safely cast to
--   <a>ConstraintGuide</a>, for instance with <a>toConstraintGuide</a>.
class (GObject o, IsDescendantOf ConstraintGuide o) => IsConstraintGuide o

-- | Cast to <a>ConstraintGuide</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toConstraintGuide :: (MonadIO m, IsConstraintGuide o) => o -> m ConstraintGuide

-- | Gets the maximum size of <i><tt>guide</tt></i>.
constraintGuideGetMaxSize :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> m (Int32, Int32)

-- | Gets the minimum size of <i><tt>guide</tt></i>.
constraintGuideGetMinSize :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> m (Int32, Int32)

-- | Retrieves the name set using <a>constraintGuideSetName</a>.
constraintGuideGetName :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> m (Maybe Text)

-- | Gets the natural size of <i><tt>guide</tt></i>.
constraintGuideGetNatSize :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> m (Int32, Int32)

-- | Retrieves the strength set using <a>constraintGuideSetStrength</a>.
constraintGuideGetStrength :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> m ConstraintStrength

-- | Creates a new <tt>GtkConstraintGuide</tt> object.
constraintGuideNew :: (HasCallStack, MonadIO m) => m ConstraintGuide

-- | Sets the maximum size of <i><tt>guide</tt></i>.
--   
--   If <i><tt>guide</tt></i> is attached to a
--   <tt>GtkConstraintLayout</tt>, the constraints will be updated to
--   reflect the new size.
constraintGuideSetMaxSize :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> Int32 -> Int32 -> m ()

-- | Sets the minimum size of <i><tt>guide</tt></i>.
--   
--   If <i><tt>guide</tt></i> is attached to a
--   <tt>GtkConstraintLayout</tt>, the constraints will be updated to
--   reflect the new size.
constraintGuideSetMinSize :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> Int32 -> Int32 -> m ()

-- | Sets a name for the given <tt>GtkConstraintGuide</tt>.
--   
--   The name is useful for debugging purposes.
constraintGuideSetName :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> Maybe Text -> m ()

-- | Sets the natural size of <i><tt>guide</tt></i>.
--   
--   If <i><tt>guide</tt></i> is attached to a
--   <tt>GtkConstraintLayout</tt>, the constraints will be updated to
--   reflect the new size.
constraintGuideSetNatSize :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> Int32 -> Int32 -> m ()

-- | Sets the strength of the constraint on the natural size of the given
--   <tt>GtkConstraintGuide</tt>.
constraintGuideSetStrength :: (HasCallStack, MonadIO m, IsConstraintGuide a) => a -> ConstraintStrength -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-height</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintGuideMaxHeight :: (IsConstraintGuide o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #maxHeight
--   </pre>
getConstraintGuideMaxHeight :: (MonadIO m, IsConstraintGuide o) => o -> m Int32

-- | Set the value of the “<tt>max-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #maxHeight <a>:=</a> value ]
--   </pre>
setConstraintGuideMaxHeight :: (MonadIO m, IsConstraintGuide o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintGuideMaxWidth :: (IsConstraintGuide o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #maxWidth
--   </pre>
getConstraintGuideMaxWidth :: (MonadIO m, IsConstraintGuide o) => o -> m Int32

-- | Set the value of the “<tt>max-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #maxWidth <a>:=</a> value ]
--   </pre>
setConstraintGuideMaxWidth :: (MonadIO m, IsConstraintGuide o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-height</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintGuideMinHeight :: (IsConstraintGuide o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #minHeight
--   </pre>
getConstraintGuideMinHeight :: (MonadIO m, IsConstraintGuide o) => o -> m Int32

-- | Set the value of the “<tt>min-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #minHeight <a>:=</a> value ]
--   </pre>
setConstraintGuideMinHeight :: (MonadIO m, IsConstraintGuide o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintGuideMinWidth :: (IsConstraintGuide o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #minWidth
--   </pre>
getConstraintGuideMinWidth :: (MonadIO m, IsConstraintGuide o) => o -> m Int32

-- | Set the value of the “<tt>min-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #minWidth <a>:=</a> value ]
--   </pre>
setConstraintGuideMinWidth :: (MonadIO m, IsConstraintGuide o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>name</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #name
--   </pre>
clearConstraintGuideName :: (MonadIO m, IsConstraintGuide o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructConstraintGuideName :: (IsConstraintGuide o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #name
--   </pre>
getConstraintGuideName :: (MonadIO m, IsConstraintGuide o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #name <a>:=</a> value ]
--   </pre>
setConstraintGuideName :: (MonadIO m, IsConstraintGuide o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>nat-height</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintGuideNatHeight :: (IsConstraintGuide o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>nat-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #natHeight
--   </pre>
getConstraintGuideNatHeight :: (MonadIO m, IsConstraintGuide o) => o -> m Int32

-- | Set the value of the “<tt>nat-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #natHeight <a>:=</a> value ]
--   </pre>
setConstraintGuideNatHeight :: (MonadIO m, IsConstraintGuide o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>nat-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintGuideNatWidth :: (IsConstraintGuide o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>nat-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #natWidth
--   </pre>
getConstraintGuideNatWidth :: (MonadIO m, IsConstraintGuide o) => o -> m Int32

-- | Set the value of the “<tt>nat-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #natWidth <a>:=</a> value ]
--   </pre>
setConstraintGuideNatWidth :: (MonadIO m, IsConstraintGuide o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strength</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructConstraintGuideStrength :: (IsConstraintGuide o, MonadIO m) => ConstraintStrength -> m (GValueConstruct o)

-- | Get the value of the “<tt>strength</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> constraintGuide #strength
--   </pre>
getConstraintGuideStrength :: (MonadIO m, IsConstraintGuide o) => o -> m ConstraintStrength

-- | Set the value of the “<tt>strength</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> constraintGuide [ #strength <a>:=</a> value ]
--   </pre>
setConstraintGuideStrength :: (MonadIO m, IsConstraintGuide o) => o -> ConstraintStrength -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ConstraintGuide.ConstraintGuide
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ConstraintGuide.ConstraintGuide
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ConstraintGuide.ConstraintGuide
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ConstraintGuide.ConstraintGuide o) => GI.Gtk.Objects.ConstraintGuide.IsConstraintGuide o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ConstraintGuide.ConstraintGuide)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ConstraintGuide.ConstraintGuide
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ConstraintGuide.ConstraintGuide


-- | A list model that wraps <a>fileEnumerateChildrenAsync</a>.
--   
--   It presents a <tt>GListModel</tt> and fills it asynchronously with the
--   <tt>GFileInfo</tt>s returned from that function.
--   
--   Enumeration will start automatically when the
--   <a>DirectoryList:file</a> property is set.
--   
--   While the <tt>GtkDirectoryList</tt> is being filled, the
--   <a>DirectoryList:loading</a> property will be set to <a>True</a>. You
--   can listen to that property if you want to show information like a
--   <tt>GtkSpinner</tt> or a "Loading..." text.
--   
--   If loading fails at any point, the <a>DirectoryList:error</a> property
--   will be set to give more indication about the failure.
--   
--   The <tt>GFileInfo</tt>s returned from a <tt>GtkDirectoryList</tt> have
--   the "standard<a>file</a>" attribute set to the <tt>GFile</tt> they
--   refer to. This way you can get at the file that is referred to in the
--   same way you would via <a>fileEnumeratorGetChild</a>. This means you
--   do not need access to the <tt>GtkDirectoryList</tt>, but can access
--   the <tt>GFile</tt> directly from the <tt>GFileInfo</tt> when operating
--   with a <tt>GtkListView</tt> or similar.
module GI.Gtk.Objects.DirectoryList

-- | Memory-managed wrapper type.
newtype DirectoryList
DirectoryList :: ManagedPtr DirectoryList -> DirectoryList

-- | Type class for types which can be safely cast to <a>DirectoryList</a>,
--   for instance with <a>toDirectoryList</a>.
class (GObject o, IsDescendantOf DirectoryList o) => IsDirectoryList o

-- | Cast to <a>DirectoryList</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDirectoryList :: (MonadIO m, IsDirectoryList o) => o -> m DirectoryList

-- | Gets the attributes queried on the children.
directoryListGetAttributes :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> m (Maybe Text)

-- | Gets the loading error, if any.
--   
--   If an error occurs during the loading process, the loading process
--   will finish and this property allows querying the error that happened.
--   This error will persist until a file is loaded again.
--   
--   An error being set does not mean that no files were loaded, and all
--   successfully queried files will remain in the list.
directoryListGetError :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> m (Maybe GError)

-- | Gets the file whose children are currently enumerated.
directoryListGetFile :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> m (Maybe File)

-- | Gets the IO priority set via <a>directoryListSetIoPriority</a>.
directoryListGetIoPriority :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> m Int32

-- | Returns whether the directory list is monitoring the directory for
--   changes.
directoryListGetMonitored :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> m Bool

-- | Returns <a>True</a> if the children enumeration is currently in
--   progress.
--   
--   Files will be added to <i><tt>self</tt></i> from time to time while
--   loading is going on. The order in which are added is undefined and may
--   change in between runs.
directoryListIsLoading :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> m Bool

-- | Creates a new <tt>GtkDirectoryList</tt>.
--   
--   The <tt>GtkDirectoryList</tt> is querying the given
--   <i><tt>file</tt></i> with the given <i><tt>attributes</tt></i>.
directoryListNew :: (HasCallStack, MonadIO m, IsFile a) => Maybe Text -> Maybe a -> m DirectoryList

-- | Sets the <i><tt>attributes</tt></i> to be enumerated and starts the
--   enumeration.
--   
--   If <i><tt>attributes</tt></i> is <a>Nothing</a>, the list of file
--   infos will still be created, it will just not contain any extra
--   attributes.
directoryListSetAttributes :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> Maybe Text -> m ()

-- | Sets the <i><tt>file</tt></i> to be enumerated and starts the
--   enumeration.
--   
--   If <i><tt>file</tt></i> is <a>Nothing</a>, the result will be an empty
--   list.
directoryListSetFile :: (HasCallStack, MonadIO m, IsDirectoryList a, IsFile b) => a -> Maybe b -> m ()

-- | Sets the IO priority to use while loading directories.
--   
--   Setting the priority while <i><tt>self</tt></i> is loading will
--   reprioritize the ongoing load as soon as possible.
--   
--   The default IO priority is <a>PRIORITY_DEFAULT</a>, which is higher
--   than the GTK redraw priority. If you are loading a lot of directories
--   in parallel, lowering it to something like
--   <a>PRIORITY_DEFAULT_IDLE</a> may increase responsiveness.
directoryListSetIoPriority :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> Int32 -> m ()

-- | Sets whether the directory list will monitor the directory for
--   changes.
--   
--   If monitoring is enabled, the <a>itemsChanged</a> signal will be
--   emitted when the directory contents change.
--   
--   When monitoring is turned on after the initial creation of the
--   directory list, the directory is reloaded to avoid missing files that
--   appeared between the initial loading and when monitoring was turned
--   on.
directoryListSetMonitored :: (HasCallStack, MonadIO m, IsDirectoryList a) => a -> Bool -> m ()

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearDirectoryListAttributes :: (MonadIO m, IsDirectoryList o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDirectoryListAttributes :: (IsDirectoryList o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #attributes
--   </pre>
getDirectoryListAttributes :: (MonadIO m, IsDirectoryList o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> directoryList [ #attributes <a>:=</a> value ]
--   </pre>
setDirectoryListAttributes :: (MonadIO m, IsDirectoryList o) => o -> Text -> m ()

-- | Get the value of the “<tt>error</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #error
--   </pre>
getDirectoryListError :: (MonadIO m, IsDirectoryList o) => o -> m (Maybe GError)

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearDirectoryListFile :: (MonadIO m, IsDirectoryList o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDirectoryListFile :: (IsDirectoryList o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #file
--   </pre>
getDirectoryListFile :: (MonadIO m, IsDirectoryList o) => o -> m (Maybe File)

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> directoryList [ #file <a>:=</a> value ]
--   </pre>
setDirectoryListFile :: (MonadIO m, IsDirectoryList o, IsFile a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>io-priority</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructDirectoryListIoPriority :: (IsDirectoryList o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>io-priority</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #ioPriority
--   </pre>
getDirectoryListIoPriority :: (MonadIO m, IsDirectoryList o) => o -> m Int32

-- | Set the value of the “<tt>io-priority</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> directoryList [ #ioPriority <a>:=</a> value ]
--   </pre>
setDirectoryListIoPriority :: (MonadIO m, IsDirectoryList o) => o -> Int32 -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #itemType
--   </pre>
getDirectoryListItemType :: (MonadIO m, IsDirectoryList o) => o -> m GType

-- | Get the value of the “<tt>loading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #loading
--   </pre>
getDirectoryListLoading :: (MonadIO m, IsDirectoryList o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>monitored</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDirectoryListMonitored :: (IsDirectoryList o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>monitored</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #monitored
--   </pre>
getDirectoryListMonitored :: (MonadIO m, IsDirectoryList o) => o -> m Bool

-- | Set the value of the “<tt>monitored</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> directoryList [ #monitored <a>:=</a> value ]
--   </pre>
setDirectoryListMonitored :: (MonadIO m, IsDirectoryList o) => o -> Bool -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> directoryList #nItems
--   </pre>
getDirectoryListNItems :: (MonadIO m, IsDirectoryList o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.DirectoryList.DirectoryList
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DirectoryList.DirectoryList
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DirectoryList.DirectoryList
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DirectoryList.DirectoryList o) => GI.Gtk.Objects.DirectoryList.IsDirectoryList o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DirectoryList.DirectoryList)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DirectoryList.DirectoryList
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DirectoryList.DirectoryList


-- | Holds the text that is displayed in a single-line text entry widget.
--   
--   A single <tt>GtkEntryBuffer</tt> object can be shared by multiple
--   widgets which will then share the same text content, but not the
--   cursor position, visibility attributes, icon etc.
--   
--   <tt>GtkEntryBuffer</tt> may be derived from. Such a derived class
--   might allow text to be stored in an alternate location, such as
--   non-pageable memory, useful in the case of important passwords. Or a
--   derived class could integrate with an application’s concept of
--   undo/redo.
module GI.Gtk.Objects.EntryBuffer

-- | Memory-managed wrapper type.
newtype EntryBuffer
EntryBuffer :: ManagedPtr EntryBuffer -> EntryBuffer

-- | Type class for types which can be safely cast to <a>EntryBuffer</a>,
--   for instance with <a>toEntryBuffer</a>.
class (GObject o, IsDescendantOf EntryBuffer o) => IsEntryBuffer o

-- | Cast to <a>EntryBuffer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toEntryBuffer :: (MonadIO m, IsEntryBuffer o) => o -> m EntryBuffer

-- | Deletes a sequence of characters from the buffer.
--   
--   <i><tt>nChars</tt></i> characters are deleted starting at
--   <i><tt>position</tt></i>. If <i><tt>nChars</tt></i> is negative, then
--   all characters until the end of the text are deleted.
--   
--   If <i><tt>position</tt></i> or <i><tt>nChars</tt></i> are out of
--   bounds, then they are coerced to sane values.
--   
--   Note that the positions are specified in characters, not bytes.
entryBufferDeleteText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Int32 -> m Word32

-- | Used when subclassing <tt>GtkEntryBuffer</tt>.
entryBufferEmitDeletedText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Word32 -> m ()

-- | Used when subclassing <tt>GtkEntryBuffer</tt>.
entryBufferEmitInsertedText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Text -> Word32 -> m ()

-- | Retrieves the length in bytes of the buffer.
--   
--   See <a>entryBufferGetLength</a>.
entryBufferGetBytes :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m CSize

-- | Retrieves the length in characters of the buffer.
entryBufferGetLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Word32

-- | Retrieves the maximum allowed length of the text in
--   <i><tt>buffer</tt></i>.
entryBufferGetMaxLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Int32

-- | Retrieves the contents of the buffer.
--   
--   The memory pointer returned by this call will not change unless this
--   object emits a signal, or is finalized.
entryBufferGetText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Text

-- | Inserts <i><tt>nChars</tt></i> characters of <i><tt>chars</tt></i>
--   into the contents of the buffer, at position <i><tt>position</tt></i>.
--   
--   If <i><tt>nChars</tt></i> is negative, then characters from chars will
--   be inserted until a null-terminator is found. If
--   <i><tt>position</tt></i> or <i><tt>nChars</tt></i> are out of bounds,
--   or the maximum buffer text length is exceeded, then they are coerced
--   to sane values.
--   
--   Note that the position and length are in characters, not in bytes.
entryBufferInsertText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Word32 -> Text -> Int32 -> m Word32

-- | Create a new <tt>GtkEntryBuffer</tt> object.
--   
--   Optionally, specify initial text to set in the buffer.
entryBufferNew :: (HasCallStack, MonadIO m) => Maybe Text -> Int32 -> m EntryBuffer

-- | Sets the maximum allowed length of the contents of the buffer.
--   
--   If the current contents are longer than the given length, then they
--   will be truncated to fit.
entryBufferSetMaxLength :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Int32 -> m ()

-- | Sets the text in the buffer.
--   
--   This is roughly equivalent to calling <a>entryBufferDeleteText</a> and
--   <a>entryBufferInsertText</a>.
--   
--   Note that <i><tt>nChars</tt></i> is in characters, not in bytes.
entryBufferSetText :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> Text -> Int32 -> m ()

-- | Get the value of the “<tt>length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryBuffer #length
--   </pre>
getEntryBufferLength :: (MonadIO m, IsEntryBuffer o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-length</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryBufferMaxLength :: (IsEntryBuffer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryBuffer #maxLength
--   </pre>
getEntryBufferMaxLength :: (MonadIO m, IsEntryBuffer o) => o -> m Int32

-- | Set the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryBuffer [ #maxLength <a>:=</a> value ]
--   </pre>
setEntryBufferMaxLength :: (MonadIO m, IsEntryBuffer o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryBufferText :: (IsEntryBuffer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryBuffer #text
--   </pre>
getEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> m Text

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryBuffer [ #text <a>:=</a> value ]
--   </pre>
setEntryBufferText :: (MonadIO m, IsEntryBuffer o) => o -> Text -> m ()

-- | The text is altered in the default handler for this signal.
--   
--   If you want access to the text after the text has been modified, use
--   <a>ConnectFlagsAfter</a>.
type EntryBufferDeletedTextCallback = Word32 -> Word32 -> IO ()

-- | Connect a signal handler for the <a>deletedText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryBuffer #deletedText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryBufferDeletedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferDeletedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deletedText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryBuffer #deletedText callback
--   </pre>
onEntryBufferDeletedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferDeletedTextCallback) -> m SignalHandlerId

-- | This signal is emitted after text is inserted into the buffer.
type EntryBufferInsertedTextCallback = Word32 -> Text -> Word32 -> IO ()

-- | Connect a signal handler for the <a>insertedText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryBuffer #insertedText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryBufferInsertedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferInsertedTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertedText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryBuffer #insertedText callback
--   </pre>
onEntryBufferInsertedText :: (IsEntryBuffer a, MonadIO m) => a -> ((?self :: a) => EntryBufferInsertedTextCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EntryBuffer.EntryBuffer
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EntryBuffer.EntryBuffer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EntryBuffer.EntryBuffer
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EntryBuffer.EntryBuffer o) => GI.Gtk.Objects.EntryBuffer.IsEntryBuffer o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EntryBuffer.EntryBuffer)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EntryBuffer.EntryBuffer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EntryBuffer.EntryBuffer


-- | Describes the filtering to be performed by a <a>FilterListModel</a>.
--   
--   The model will use the filter to determine if it should include items
--   or not by calling <a>filterMatch</a> for each item and only keeping
--   the ones that the function returns true for.
--   
--   Filters may change what items they match through their lifetime. In
--   that case, they will emit the <a>Filter::changed</a> signal to notify
--   that previous filter results are no longer valid and that items should
--   be checked again via <a>filterMatch</a>.
--   
--   GTK provides various pre-made filter implementations for common
--   filtering operations. These filters often include properties that can
--   be linked to various widgets to easily allow searches.
--   
--   However, in particular for large lists or complex search methods, it
--   is also possible to subclass <tt>GtkFilter</tt> and provide one's own
--   filter.
module GI.Gtk.Objects.Filter

-- | Memory-managed wrapper type.
newtype Filter
Filter :: ManagedPtr Filter -> Filter

-- | Type class for types which can be safely cast to <a>Filter</a>, for
--   instance with <a>toFilter</a>.
class (GObject o, IsDescendantOf Filter o) => IsFilter o

-- | Cast to <a>Filter</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFilter :: (MonadIO m, IsFilter o) => o -> m Filter

-- | Notifies all users of the filter that it has changed.
--   
--   This emits the <a>Filter::changed</a> signal. Users of the filter
--   should then check items again via <a>filterMatch</a>.
--   
--   Depending on the <i><tt>change</tt></i> parameter, not all items need
--   to be changed, but only some. Refer to the <a>FilterChange</a>
--   documentation for details.
--   
--   This function is intended for implementers of <tt>GtkFilter</tt>
--   subclasses and should not be called from other functions.
filterChanged :: (HasCallStack, MonadIO m, IsFilter a) => a -> FilterChange -> m ()

-- | Gets the known strictness of a filter.
--   
--   If the strictness is not known, <a>FilterMatchSome</a> is returned.
--   
--   This value may change after emission of the <a>Filter::changed</a>
--   signal.
--   
--   This function is meant purely for optimization purposes. Filters can
--   choose to omit implementing it, but <tt>GtkFilterListModel</tt> uses
--   it.
filterGetStrictness :: (HasCallStack, MonadIO m, IsFilter a) => a -> m FilterMatch

-- | Checks if the given <i><tt>item</tt></i> is matched by the filter or
--   not.
filterMatch :: (HasCallStack, MonadIO m, IsFilter a, IsObject b) => a -> b -> m Bool

-- | Emitted whenever the filter changed.
--   
--   Users of the filter should then check items again via
--   <a>filterMatch</a>.
--   
--   <tt>GtkFilterListModel</tt> handles this signal automatically.
--   
--   Depending on the <i><tt>change</tt></i> parameter, not all items need
--   to be checked, but only some. Refer to the <a>FilterChange</a>
--   documentation for details.
type FilterChangedCallback = FilterChange -> IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> filter #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFilterChanged :: (IsFilter a, MonadIO m) => a -> ((?self :: a) => FilterChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> filter #changed callback
--   </pre>
onFilterChanged :: (IsFilter a, MonadIO m) => a -> ((?self :: a) => FilterChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Filter.Filter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Filter.Filter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Filter.Filter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Filter.Filter o) => GI.Gtk.Objects.Filter.IsFilter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Filter.Filter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Filter.Filter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Filter.Filter


-- | Filters files by name or mime type.
--   
--   <tt>GtkFileFilter</tt> can be used to restrict the files being shown
--   in a file chooser. Files can be filtered based on their name (with
--   <a>fileFilterAddPattern</a> or <a>fileFilterAddSuffix</a>) or on their
--   mime type (with <a>fileFilterAddMimeType</a>).
--   
--   Filtering by mime types handles aliasing and subclassing of mime
--   types; e.g. a filter for text/plain also matches a file with mime type
--   application/rtf, since application/rtf is a subclass of text/plain.
--   Note that <tt>GtkFileFilter</tt> allows wildcards for the subtype of a
--   mime type, so you can e.g. filter for image/\*.
--   
--   Normally, file filters are used by adding them to a file chooser (see
--   <a>fileDialogSetFilters</a>), but it is also possible to manually use
--   a file filter on any <a>FilterListModel</a> containing
--   <tt>GFileInfo</tt> objects.
--   
--   <h1>GtkFileFilter as GtkBuildable</h1>
--   
--   The <tt>GtkFileFilter</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports adding rules using the <tt>&lt;mime-types&gt;</tt>
--   and <tt>&lt;patterns&gt;</tt> and <tt>&lt;suffixes&gt;</tt> elements
--   and listing the rules within. Specifying a <tt>&lt;mime-type&gt;</tt>
--   or <tt>&lt;pattern&gt;</tt> or <tt>&lt;suffix&gt;</tt> has the same
--   effect as as calling <a>fileFilterAddMimeType</a> or
--   <a>fileFilterAddPattern</a> or <a>fileFilterAddSuffix</a>.
--   
--   An example of a UI definition fragment specifying
--   <tt>GtkFileFilter</tt> rules:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkFileFilter"&gt;
--     &lt;property name="name" translatable="yes"&gt;Text and Images&lt;/property&gt;
--     &lt;mime-types&gt;
--       &lt;mime-type&gt;text/plain&lt;/mime-type&gt;
--       &lt;mime-type&gt;image/ *&lt;/mime-type&gt;
--     &lt;/mime-types&gt;
--     &lt;patterns&gt;
--       &lt;pattern&gt;*.txt&lt;/pattern&gt;
--     &lt;/patterns&gt;
--     &lt;suffixes&gt;
--       &lt;suffix&gt;png&lt;/suffix&gt;
--     &lt;/suffixes&gt;
--   &lt;/object&gt;
--   </pre>
module GI.Gtk.Objects.FileFilter

-- | Memory-managed wrapper type.
newtype FileFilter
FileFilter :: ManagedPtr FileFilter -> FileFilter

-- | Type class for types which can be safely cast to <a>FileFilter</a>,
--   for instance with <a>toFileFilter</a>.
class (GObject o, IsDescendantOf FileFilter o) => IsFileFilter o

-- | Cast to <a>FileFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFileFilter :: (MonadIO m, IsFileFilter o) => o -> m FileFilter

-- | Adds a rule allowing a given mime type.
fileFilterAddMimeType :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Text -> m ()

-- | Adds a rule allowing a given array of mime types. It can for example
--   be used with <a>Gly.Loader.get_mime_types</a>.
--   
--   This is equivalent to calling <a>fileFilterAddMimeType</a> for all the
--   supported mime types.
--   
--   <i>Since: 4.22</i>
fileFilterAddMimeTypes :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> [Text] -> m ()

-- | Adds a rule allowing a shell style glob pattern.
--   
--   Note that it depends on the platform whether pattern matching ignores
--   case or not. On Windows, it does, on other platforms, it doesn't.
fileFilterAddPattern :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Text -> m ()

-- | Adds a rule allowing image files in the formats supported by
--   <tt>GdkPixbuf</tt>.
--   
--   This is equivalent to calling <a>fileFilterAddMimeType</a> for all the
--   supported mime types.

-- | <i>Deprecated: (Since version 4.20)Use the api of your image loading
--   framework (e.g. glycin)to enumerate supported formats</i>
fileFilterAddPixbufFormats :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m ()

-- | Adds a suffix match rule to a filter.
--   
--   This is similar to adding a match for the pattern
--   "*.<i><tt>suffix</tt></i>"
--   
--   An exaple to filter files with the suffix ".sub":
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   gtk_file_filter_add_suffix (filter, "sub");
--   </pre>
--   
--   Filters with multiple dots are allowed.
--   
--   In contrast to pattern matches, suffix matches are *always*
--   case-insensitive.
--   
--   <i>Since: 4.4</i>
fileFilterAddSuffix :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Text -> m ()

-- | Gets the attributes that need to be filled in for the
--   <tt>GFileInfo</tt> passed to this filter.
--   
--   This function will not typically be used by applications; it is
--   intended for use in file chooser implementation.
fileFilterGetAttributes :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m [Text]

-- | Gets the human-readable name for the filter.
--   
--   See <a>fileFilterSetName</a>.
fileFilterGetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m (Maybe Text)

-- | Creates a new <tt>GtkFileFilter</tt> with no rules added to it.
--   
--   Such a filter doesn’t accept any files, so is not particularly useful
--   until you add rules with <a>fileFilterAddMimeType</a>,
--   <a>fileFilterAddPattern</a>, <a>fileFilterAddSuffix</a> or
--   <a>fileFilterAddPixbufFormats</a>.
--   
--   To create a filter that accepts any file, use:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkFileFilter *filter = gtk_file_filter_new ();
--   gtk_file_filter_add_pattern (filter, "*");
--   </pre>
fileFilterNew :: (HasCallStack, MonadIO m) => m FileFilter

-- | Deserialize a file filter from a <tt>GVariant</tt>.
--   
--   The variant must be in the format produced by
--   <a>fileFilterToGvariant</a>.
fileFilterNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m FileFilter

-- | Sets a human-readable name of the filter.
--   
--   This is the string that will be displayed in the user interface if
--   there is a selectable list of filters.
fileFilterSetName :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> Maybe Text -> m ()

-- | Serialize a file filter to an <tt>a{sv}</tt> variant.
fileFilterToGvariant :: (HasCallStack, MonadIO m, IsFileFilter a) => a -> m GVariant

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mime-types</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFileFilterMimeTypes :: (IsFileFilter o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Set the value of the “<tt>name</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #name
--   </pre>
clearFileFilterName :: (MonadIO m, IsFileFilter o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileFilterName :: (IsFileFilter o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileFilter #name
--   </pre>
getFileFilterName :: (MonadIO m, IsFileFilter o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileFilter [ #name <a>:=</a> value ]
--   </pre>
setFileFilterName :: (MonadIO m, IsFileFilter o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>patterns</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFileFilterPatterns :: (IsFileFilter o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>suffixes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFileFilterSuffixes :: (IsFileFilter o, MonadIO m) => [Text] -> m (GValueConstruct o)
instance GHC.Classes.Eq GI.Gtk.Objects.FileFilter.FileFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FileFilter.FileFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FileFilter.FileFilter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FileFilter.FileFilter o) => GI.Gtk.Objects.FileFilter.IsFileFilter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FileFilter.FileFilter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FileFilter.FileFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FileFilter.FileFilter


-- | <tt>GtkFileChooser</tt> is an interface that can be implemented by
--   file selection widgets.
--   
--   In GTK, the main objects that implement this interface are
--   <a>FileChooserWidget</a> and <a>FileChooserDialog</a>.
--   
--   You do not need to write an object that implements the
--   <tt>GtkFileChooser</tt> interface unless you are trying to adapt an
--   existing file selector to expose a standard programming interface.
--   
--   <tt>GtkFileChooser</tt> allows for shortcuts to various places in the
--   filesystem. In the default implementation these are displayed in the
--   left pane. It may be a bit confusing at first that these shortcuts
--   come from various sources and in various flavours, so lets explain the
--   terminology here:
--   
--   <ul>
--   <li>Bookmarks: are created by the user, by dragging folders from the
--   right pane to the left pane, or by using the “Add”. Bookmarks can be
--   renamed and deleted by the user.</li>
--   <li>Shortcuts: can be provided by the application. For example, a
--   Paint program may want to add a shortcut for a Clipart folder.
--   Shortcuts cannot be modified by the user.</li>
--   <li>Volumes: are provided by the underlying filesystem abstraction.
--   They are the “roots” of the filesystem.</li>
--   </ul>
--   
--   <h1>File Names and Encodings</h1>
--   
--   When the user is finished selecting files in a
--   <tt>GtkFileChooser</tt>, your program can get the selected filenames
--   as <tt>GFile</tt>s.
--   
--   <h1>Adding options</h1>
--   
--   You can add extra widgets to a file chooser to provide options that
--   are not present in the default design, by using
--   <a>fileChooserAddChoice</a>. Each choice has an identifier and a user
--   visible label; additionally, each choice can have multiple options. If
--   a choice has no option, it will be rendered as a check button with the
--   given label; if a choice has options, it will be rendered as a combo
--   box.
module GI.Gtk.Interfaces.FileChooser

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
newtype FileChooser

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
FileChooser :: ManagedPtr FileChooser -> FileChooser

-- | Type class for types which can be safely cast to <a>FileChooser</a>,
--   for instance with <a>toFileChooser</a>.
class (GObject o, IsDescendantOf FileChooser o) => IsFileChooser o

-- | Cast to <a>FileChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFileChooser :: (MonadIO m, IsFileChooser o) => o -> m FileChooser

-- | Adds a 'choice' to the file chooser.
--   
--   This is typically implemented as a combobox or, for boolean choices,
--   as a checkbutton. You can select a value using
--   <a>fileChooserSetChoice</a> before the dialog is shown, and you can
--   obtain the user-selected value in the <a>Dialog::response</a> signal
--   handler using <a>fileChooserGetChoice</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserAddChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> Maybe [Text] -> Maybe [Text] -> m ()

-- | Adds <i><tt>filter</tt></i> to the list of filters that the user can
--   select between.
--   
--   When a filter is selected, only files that are passed by that filter
--   are displayed.
--   
--   Note that the <i><tt>chooser</tt></i> takes ownership of the filter if
--   it is floating, so you have to ref and sink it if you want to keep a
--   reference.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserAddFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Adds a folder to be displayed with the shortcut folders in a file
--   chooser.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserAddShortcutFolder :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Gets the type of operation that the file chooser is performing.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetAction :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m FileChooserAction

-- | Gets the currently selected option in the 'choice' with the given ID.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m (Maybe Text)

-- | Gets whether file chooser will offer to create new folders.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetCreateFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Gets the current folder of <i><tt>chooser</tt></i> as <tt>GFile</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetCurrentFolder :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe File)

-- | Gets the current name in the file selector, as entered by the user.
--   
--   This is meant to be used in save dialogs, to get the currently typed
--   filename when the file itself does not exist yet.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetCurrentName :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe Text)

-- | Gets the <tt>GFile</tt> for the currently selected file in the file
--   selector.
--   
--   If multiple files are selected, one of the files will be returned at
--   random.
--   
--   If the file chooser is in folder mode, this function returns the
--   selected folder.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetFile :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe File)

-- | Lists all the selected files and subfolders in the current folder of
--   <i><tt>chooser</tt></i> as <tt>GFile</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetFiles :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m ListModel

-- | Gets the current filter.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetFilter :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m (Maybe FileFilter)

-- | Gets the current set of user-selectable filters, as a list model.
--   
--   See <a>fileChooserAddFilter</a> and <a>fileChooserRemoveFilter</a> for
--   changing individual filters.
--   
--   You should not modify the returned list model. Future changes to
--   <i><tt>chooser</tt></i> may or may not affect the returned model.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetFilters :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m ListModel

-- | Gets whether multiple files can be selected in the file chooser.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetSelectMultiple :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m Bool

-- | Queries the list of shortcut folders in the file chooser.
--   
--   You should not modify the returned list model. Future changes to
--   <i><tt>chooser</tt></i> may or may not affect the returned model.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserGetShortcutFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> m ListModel

-- | Removes a 'choice' that has been added with
--   <a>fileChooserAddChoice</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserRemoveChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Removes <i><tt>filter</tt></i> from the list of filters that the user
--   can select between.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserRemoveFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Removes a folder from the shortcut folders in a file chooser.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserRemoveShortcutFolder :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Sets the type of operation that the chooser is performing.
--   
--   The user interface is adapted to suit the selected action.
--   
--   For example, an option to create a new folder might be shown if the
--   action is <a>FileChooserActionSave</a> but not if the action is
--   <a>FileChooserActionOpen</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetAction :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> FileChooserAction -> m ()

-- | Selects an option in a 'choice' that has been added with
--   <a>fileChooserAddChoice</a>.
--   
--   For a boolean choice, the possible options are "true" and "false".

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetChoice :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> Text -> m ()

-- | Sets whether file chooser will offer to create new folders.
--   
--   This is only relevant if the action is not set to be
--   <a>FileChooserActionOpen</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetCreateFolders :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Sets the current folder for <i><tt>chooser</tt></i> from a
--   <tt>GFile</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetCurrentFolder :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> Maybe b -> m ()

-- | Sets the current name in the file selector, as if entered by the user.
--   
--   Note that the name passed in here is a UTF-8 string rather than a
--   filename. This function is meant for such uses as a suggested name in
--   a “Save As...” dialog. You can pass “Untitled.doc” or a similarly
--   suitable suggestion for the <i><tt>name</tt></i>.
--   
--   If you want to preselect a particular existing file, you should use
--   <a>fileChooserSetFile</a> instead.
--   
--   Please see the documentation for those functions for an example of
--   using <a>fileChooserSetCurrentName</a> as well.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetCurrentName :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Text -> m ()

-- | Sets <i><tt>file</tt></i> as the current filename for the file
--   chooser.
--   
--   This includes changing to the file’s parent folder and actually
--   selecting the file in list. If the <i><tt>chooser</tt></i> is in
--   <a>FileChooserActionSave</a> mode, the file’s base name will also
--   appear in the dialog’s file name entry.
--   
--   If the file name isn’t in the current folder of
--   <i><tt>chooser</tt></i>, then the current folder of
--   <i><tt>chooser</tt></i> will be changed to the folder containing
--   <i><tt>file</tt></i>.
--   
--   Note that the file must exist, or nothing will be done except for the
--   directory change.
--   
--   If you are implementing a save dialog, you should use this function if
--   you already have a file name to which the user may save; for example,
--   when the user opens an existing file and then does “Save As…”. If you
--   don’t have a file name already — for example, if the user just created
--   a new file and is saving it for the first time, do not call this
--   function.
--   
--   Instead, use something similar to this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   prepare_file_chooser (GtkFileChooser *chooser,
--                         GFile          *existing_file)
--   {
--     gboolean document_is_new = (existing_file == NULL);
--   
--     if (document_is_new)
--       {
--         GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
--         // the user just created a new document
--         gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
--         gtk_file_chooser_set_current_name (chooser, "Untitled document");
--         g_object_unref (default_file_for_saving);
--       }
--     else
--       {
--         // the user edited an existing document
--         gtk_file_chooser_set_file (chooser, existing_file, NULL);
--       }
--   }
--   </pre>

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetFile :: (HasCallStack, MonadIO m, IsFileChooser a, IsFile b) => a -> b -> m ()

-- | Sets the current filter.
--   
--   Only the files that pass the filter will be displayed. If the
--   user-selectable list of filters is non-empty, then the filter should
--   be one of the filters in that list.
--   
--   Setting the current filter when the list of filters is empty is useful
--   if you want to restrict the displayed set of files without letting the
--   user change it.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetFilter :: (HasCallStack, MonadIO m, IsFileChooser a, IsFileFilter b) => a -> b -> m ()

-- | Sets whether multiple files can be selected in the file chooser.
--   
--   This is only relevant if the action is set to be
--   <a>FileChooserActionOpen</a> or <a>FileChooserActionSelectFolder</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserSetSelectMultiple :: (HasCallStack, MonadIO m, IsFileChooser a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileChooserAction :: (IsFileChooser o, MonadIO m) => FileChooserAction -> m (GValueConstruct o)

-- | Get the value of the “<tt>action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #action
--   </pre>
getFileChooserAction :: (MonadIO m, IsFileChooser o) => o -> m FileChooserAction

-- | Set the value of the “<tt>action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #action <a>:=</a> value ]
--   </pre>
setFileChooserAction :: (MonadIO m, IsFileChooser o) => o -> FileChooserAction -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>create-folders</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileChooserCreateFolders :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>create-folders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #createFolders
--   </pre>
getFileChooserCreateFolders :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>create-folders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #createFolders <a>:=</a> value ]
--   </pre>
setFileChooserCreateFolders :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileChooserFilter :: (IsFileChooser o, MonadIO m, IsFileFilter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #filter
--   </pre>
getFileChooserFilter :: (MonadIO m, IsFileChooser o) => o -> m (Maybe FileFilter)

-- | Set the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #filter <a>:=</a> value ]
--   </pre>
setFileChooserFilter :: (MonadIO m, IsFileChooser o, IsFileFilter a) => o -> a -> m ()

-- | Get the value of the “<tt>filters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #filters
--   </pre>
getFileChooserFilters :: (MonadIO m, IsFileChooser o) => o -> m (Maybe ListModel)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>select-multiple</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileChooserSelectMultiple :: (IsFileChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>select-multiple</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #selectMultiple
--   </pre>
getFileChooserSelectMultiple :: (MonadIO m, IsFileChooser o) => o -> m Bool

-- | Set the value of the “<tt>select-multiple</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooser [ #selectMultiple <a>:=</a> value ]
--   </pre>
setFileChooserSelectMultiple :: (MonadIO m, IsFileChooser o) => o -> Bool -> m ()

-- | Get the value of the “<tt>shortcut-folders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooser #shortcutFolders
--   </pre>
getFileChooserShortcutFolders :: (MonadIO m, IsFileChooser o) => o -> m (Maybe ListModel)
instance GHC.Classes.Eq GI.Gtk.Interfaces.FileChooser.FileChooser
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.FileChooser.FileChooser
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.FileChooser.FileChooser
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.FileChooser.FileChooser o) => GI.Gtk.Interfaces.FileChooser.IsFileChooser o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.FileChooser.FileChooser)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.FileChooser.FileChooser
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.FileChooser.FileChooser


-- | A list model that filters the elements of another model.
--   
--   It hides some elements from the underlying model according to criteria
--   given by a <tt>GtkFilter</tt>.
--   
--   The model can be set up to do incremental filtering, so that filtering
--   long lists doesn't block the UI. See
--   <a>filterListModelSetIncremental</a> for details.
--   
--   <tt>GtkFilterListModel</tt> passes through sections from the
--   underlying model.
module GI.Gtk.Objects.FilterListModel

-- | Memory-managed wrapper type.
newtype FilterListModel
FilterListModel :: ManagedPtr FilterListModel -> FilterListModel

-- | Type class for types which can be safely cast to
--   <a>FilterListModel</a>, for instance with <a>toFilterListModel</a>.
class (GObject o, IsDescendantOf FilterListModel o) => IsFilterListModel o

-- | Cast to <a>FilterListModel</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFilterListModel :: (MonadIO m, IsFilterListModel o) => o -> m FilterListModel

-- | Gets the <tt>GtkFilter</tt> currently set on <i><tt>self</tt></i>.
filterListModelGetFilter :: (HasCallStack, MonadIO m, IsFilterListModel a) => a -> m (Maybe Filter)

-- | Returns whether incremental filtering is enabled.
--   
--   See <a>filterListModelSetIncremental</a>.
filterListModelGetIncremental :: (HasCallStack, MonadIO m, IsFilterListModel a) => a -> m Bool

-- | Gets the model currently filtered or <a>Nothing</a> if none.
filterListModelGetModel :: (HasCallStack, MonadIO m, IsFilterListModel a) => a -> m (Maybe ListModel)

-- | Returns the number of items that have not been filtered yet.
--   
--   You can use this value to check if <i><tt>self</tt></i> is busy
--   filtering by comparing the return value to 0 or you can compute the
--   percentage of the filter remaining by dividing the return value by the
--   total number of items in the underlying model:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   pending = gtk_filter_list_model_get_pending (self);
--   model = gtk_filter_list_model_get_model (self);
--   percentage = pending / (double) g_list_model_get_n_items (model);
--   </pre>
--   
--   If no filter operation is ongoing - in particular when
--   <a>FilterListModel:incremental</a> is <a>False</a> - this function
--   returns 0.
filterListModelGetPending :: (HasCallStack, MonadIO m, IsFilterListModel a) => a -> m Word32

-- | Returns whether watching items is enabled.
--   
--   See <a>filterListModelSetWatchItems</a>.
--   
--   <i>Since: 4.20</i>
filterListModelGetWatchItems :: (HasCallStack, MonadIO m, IsFilterListModel a) => a -> m Bool

-- | Creates a new <tt>GtkFilterListModel</tt> that will filter
--   <i><tt>model</tt></i> using the given <i><tt>filter</tt></i>.
filterListModelNew :: (HasCallStack, MonadIO m, IsListModel a, IsFilter b) => Maybe a -> Maybe b -> m FilterListModel

-- | Sets the filter used to filter items.
filterListModelSetFilter :: (HasCallStack, MonadIO m, IsFilterListModel a, IsFilter b) => a -> Maybe b -> m ()

-- | Sets the filter model to do an incremental sort.
--   
--   When incremental filtering is enabled, the <tt>GtkFilterListModel</tt>
--   will not run filters immediately, but will instead queue an idle
--   handler that incrementally filters the items and adds them to the
--   list. This of course means that items are not instantly added to the
--   list, but only appear incrementally.
--   
--   When your filter blocks the UI while filtering, you might consider
--   turning this on. Depending on your model and filters, this may become
--   interesting around 10,000 to 100,000 items.
--   
--   By default, incremental filtering is disabled.
--   
--   See <a>filterListModelGetPending</a> for progress information about an
--   ongoing incremental filtering operation.
filterListModelSetIncremental :: (HasCallStack, MonadIO m, IsFilterListModel a) => a -> Bool -> m ()

-- | Sets the model to be filtered.
--   
--   Note that GTK makes no effort to ensure that <i><tt>model</tt></i>
--   conforms to the item type of <i><tt>self</tt></i>. It assumes that the
--   caller knows what they are doing and have set up an appropriate filter
--   to ensure that item types match.
filterListModelSetModel :: (HasCallStack, MonadIO m, IsFilterListModel a, IsListModel b) => a -> Maybe b -> m ()

-- | Sets the filter model to monitor properties of its items.
--   
--   This allows implementations of <a>Filter</a> that support expression
--   watching to react to property changes. This property has no effect if
--   the current filter doesn't support watching items.
--   
--   By default, watching items is disabled.
--   
--   <i>Since: 4.20</i>
filterListModelSetWatchItems :: (HasCallStack, MonadIO m, IsFilterListModel a) => a -> Bool -> m ()

-- | Set the value of the “<tt>filter</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #filter
--   </pre>
clearFilterListModelFilter :: (MonadIO m, IsFilterListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFilterListModelFilter :: (IsFilterListModel o, MonadIO m, IsFilter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> filterListModel #filter
--   </pre>
getFilterListModelFilter :: (MonadIO m, IsFilterListModel o) => o -> m (Maybe Filter)

-- | Set the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> filterListModel [ #filter <a>:=</a> value ]
--   </pre>
setFilterListModelFilter :: (MonadIO m, IsFilterListModel o, IsFilter a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>incremental</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFilterListModelIncremental :: (IsFilterListModel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>incremental</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> filterListModel #incremental
--   </pre>
getFilterListModelIncremental :: (MonadIO m, IsFilterListModel o) => o -> m Bool

-- | Set the value of the “<tt>incremental</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> filterListModel [ #incremental <a>:=</a> value ]
--   </pre>
setFilterListModelIncremental :: (MonadIO m, IsFilterListModel o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> filterListModel #itemType
--   </pre>
getFilterListModelItemType :: (MonadIO m, IsFilterListModel o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearFilterListModelModel :: (MonadIO m, IsFilterListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFilterListModelModel :: (IsFilterListModel o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> filterListModel #model
--   </pre>
getFilterListModelModel :: (MonadIO m, IsFilterListModel o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> filterListModel [ #model <a>:=</a> value ]
--   </pre>
setFilterListModelModel :: (MonadIO m, IsFilterListModel o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> filterListModel #nItems
--   </pre>
getFilterListModelNItems :: (MonadIO m, IsFilterListModel o) => o -> m Word32

-- | Get the value of the “<tt>pending</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> filterListModel #pending
--   </pre>
getFilterListModelPending :: (MonadIO m, IsFilterListModel o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>watch-items</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFilterListModelWatchItems :: (IsFilterListModel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>watch-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> filterListModel #watchItems
--   </pre>
getFilterListModelWatchItems :: (MonadIO m, IsFilterListModel o) => o -> m Bool

-- | Set the value of the “<tt>watch-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> filterListModel [ #watchItems <a>:=</a> value ]
--   </pre>
setFilterListModelWatchItems :: (MonadIO m, IsFilterListModel o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.FilterListModel.FilterListModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FilterListModel.FilterListModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FilterListModel.FilterListModel
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FilterListModel.FilterListModel o) => GI.Gtk.Objects.FilterListModel.IsFilterListModel o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FilterListModel.FilterListModel)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FilterListModel.FilterListModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FilterListModel.FilterListModel


-- | A list model that concatenates other list models.
--   
--   <tt>GtkFlattenListModel</tt> takes a list model containing list
--   models, and flattens it into a single model. Each list model becomes a
--   section in the single model.
module GI.Gtk.Objects.FlattenListModel

-- | Memory-managed wrapper type.
newtype FlattenListModel
FlattenListModel :: ManagedPtr FlattenListModel -> FlattenListModel

-- | Type class for types which can be safely cast to
--   <a>FlattenListModel</a>, for instance with <a>toFlattenListModel</a>.
class (GObject o, IsDescendantOf FlattenListModel o) => IsFlattenListModel o

-- | Cast to <a>FlattenListModel</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFlattenListModel :: (MonadIO m, IsFlattenListModel o) => o -> m FlattenListModel

-- | Gets the model set via <a>flattenListModelSetModel</a>.
flattenListModelGetModel :: (HasCallStack, MonadIO m, IsFlattenListModel a) => a -> m (Maybe ListModel)

-- | Returns the model containing the item at the given position.
flattenListModelGetModelForItem :: (HasCallStack, MonadIO m, IsFlattenListModel a) => a -> Word32 -> m (Maybe ListModel)

-- | Creates a new <tt>GtkFlattenListModel</tt> that flattens
--   <i><tt>list</tt></i>.
flattenListModelNew :: (HasCallStack, MonadIO m, IsListModel a) => Maybe a -> m FlattenListModel

-- | Sets a new model to be flattened.
flattenListModelSetModel :: (HasCallStack, MonadIO m, IsFlattenListModel a, IsListModel b) => a -> Maybe b -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flattenListModel #itemType
--   </pre>
getFlattenListModelItemType :: (MonadIO m, IsFlattenListModel o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearFlattenListModelModel :: (MonadIO m, IsFlattenListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFlattenListModelModel :: (IsFlattenListModel o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flattenListModel #model
--   </pre>
getFlattenListModelModel :: (MonadIO m, IsFlattenListModel o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flattenListModel [ #model <a>:=</a> value ]
--   </pre>
setFlattenListModelModel :: (MonadIO m, IsFlattenListModel o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flattenListModel #nItems
--   </pre>
getFlattenListModelNItems :: (MonadIO m, IsFlattenListModel o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.FlattenListModel.FlattenListModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FlattenListModel.FlattenListModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FlattenListModel.FlattenListModel
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FlattenListModel.FlattenListModel o) => GI.Gtk.Objects.FlattenListModel.IsFlattenListModel o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FlattenListModel.FlattenListModel)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FlattenListModel.FlattenListModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FlattenListModel.FlattenListModel


-- | Contains information found when looking up an icon in
--   <tt>GtkIconTheme</tt> or loading it from a file.
--   
--   <tt>GtkIconPaintable</tt> implements <tt>GdkPaintable</tt> and
--   <tt>GtkSymbolicPaintable</tt>.
module GI.Gtk.Objects.IconPaintable

-- | Memory-managed wrapper type.
newtype IconPaintable
IconPaintable :: ManagedPtr IconPaintable -> IconPaintable

-- | Type class for types which can be safely cast to <a>IconPaintable</a>,
--   for instance with <a>toIconPaintable</a>.
class (GObject o, IsDescendantOf IconPaintable o) => IsIconPaintable o

-- | Cast to <a>IconPaintable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIconPaintable :: (MonadIO m, IsIconPaintable o) => o -> m IconPaintable

-- | Gets the <tt>GFile</tt> that was used to load the icon.
--   
--   Returns <a>Nothing</a> if the icon was not loaded from a file.
iconPaintableGetFile :: (HasCallStack, MonadIO m, IsIconPaintable a) => a -> m (Maybe File)

-- | Get the icon name being used for this icon.
--   
--   When an icon looked up in the icon theme was not available, the icon
--   theme may use fallback icons - either those specified to
--   <a>iconThemeLookupIcon</a> or the always-available "image-missing".
--   The icon chosen is returned by this function.
--   
--   If the icon was created without an icon theme, this function returns
--   <a>Nothing</a>.

-- | <i>Deprecated: (Since version 4.20)</i>
iconPaintableGetIconName :: (HasCallStack, MonadIO m, IsIconPaintable a) => a -> m (Maybe [Char])

-- | Checks if the icon is symbolic or not.
--   
--   This currently uses only the file name and not the file contents for
--   determining this. This behaviour may change in the future.

-- | <i>Deprecated: (Since version 4.20)</i>
iconPaintableIsSymbolic :: (HasCallStack, MonadIO m, IsIconPaintable a) => a -> m Bool

-- | Creates a <tt>GtkIconPaintable</tt> for a file with a given size and
--   scale.
--   
--   The icon can then be rendered by using it as a <tt>GdkPaintable</tt>.
iconPaintableNewForFile :: (HasCallStack, MonadIO m, IsFile a) => a -> Int32 -> Int32 -> m IconPaintable

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconPaintableFile :: (IsIconPaintable o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconPaintable #file
--   </pre>
getIconPaintableFile :: (MonadIO m, IsIconPaintable o) => o -> m (Maybe File)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructIconPaintableIconName :: (IsIconPaintable o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconPaintable #iconName
--   </pre>
getIconPaintableIconName :: (MonadIO m, IsIconPaintable o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-symbolic</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconPaintableIsSymbolic :: (IsIconPaintable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-symbolic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconPaintable #isSymbolic
--   </pre>
getIconPaintableIsSymbolic :: (MonadIO m, IsIconPaintable o) => o -> m Bool

-- | Set the value of the “<tt>is-symbolic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconPaintable [ #isSymbolic <a>:=</a> value ]
--   </pre>
setIconPaintableIsSymbolic :: (MonadIO m, IsIconPaintable o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconPaintableScale :: (IsIconPaintable o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconPaintable #scale
--   </pre>
getIconPaintableScale :: (MonadIO m, IsIconPaintable o) => o -> m Int32

-- | Set the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconPaintable [ #scale <a>:=</a> value ]
--   </pre>
setIconPaintableScale :: (MonadIO m, IsIconPaintable o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconPaintableSize :: (IsIconPaintable o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconPaintable #size
--   </pre>
getIconPaintableSize :: (MonadIO m, IsIconPaintable o) => o -> m Int32

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconPaintable [ #size <a>:=</a> value ]
--   </pre>
setIconPaintableSize :: (MonadIO m, IsIconPaintable o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.IconPaintable.IconPaintable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.IconPaintable.IconPaintable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.IconPaintable.IconPaintable
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.IconPaintable.IconPaintable)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.IconPaintable.IconPaintable o) => GI.Gtk.Objects.IconPaintable.IsIconPaintable o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.IconPaintable.IconPaintable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.IconPaintable.IconPaintable


-- | Loads themed icons.
--   
--   The main reason for using a name rather than simply providing a
--   filename is to allow different icons to be used depending on what
--   “icon theme” is selected by the user. The operation of icon themes on
--   Linux and Unix follows the <a>Icon Theme Specification</a> There is a
--   fallback icon theme, named <tt>hicolor</tt>, where applications should
--   install their icons, but additional icon themes can be installed as
--   operating system vendors and users choose.
--   
--   In many cases, named themes are used indirectly, via <a>Image</a>
--   rather than directly, but looking up icons directly is also simple.
--   The <tt>GtkIconTheme</tt> object acts as a database of all the icons
--   in the current theme. You can create new <tt>GtkIconTheme</tt>
--   objects, but it’s much more efficient to use the standard icon theme
--   of the <tt>GtkWidget</tt> so that the icon information is shared with
--   other people looking up icons.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkIconTheme *icon_theme;
--   GtkIconPaintable *icon;
--   GdkPaintable *paintable;
--   
--   icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (my_widget));
--   icon = gtk_icon_theme_lookup_icon (icon_theme,
--                                      "my-icon-name", // icon name
--                                      48, // icon size
--                                      1,  // scale
--                                      0,  // flags);
--   paintable = GDK_PAINTABLE (icon);
--   // Use the paintable
--   g_object_unref (icon);
--   </pre>
module GI.Gtk.Objects.IconTheme

-- | Memory-managed wrapper type.
newtype IconTheme
IconTheme :: ManagedPtr IconTheme -> IconTheme

-- | Type class for types which can be safely cast to <a>IconTheme</a>, for
--   instance with <a>toIconTheme</a>.
class (GObject o, IsDescendantOf IconTheme o) => IsIconTheme o

-- | Cast to <a>IconTheme</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIconTheme :: (MonadIO m, IsIconTheme o) => o -> m IconTheme

-- | Adds a resource path that will be looked at when looking for icons,
--   similar to search paths.
--   
--   See <a>iconThemeSetResourcePath</a>.
--   
--   This function should be used to make application-specific icons
--   available as part of the icon theme.
iconThemeAddResourcePath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m ()

-- | Appends a directory to the search path.
--   
--   See <a>iconThemeSetSearchPath</a>.
iconThemeAddSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> [Char] -> m ()

-- | Returns the display that the <tt>GtkIconTheme</tt> object was created
--   for.
iconThemeGetDisplay :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m (Maybe Display)

-- | Gets the icon theme object associated with <i><tt>display</tt></i>.
--   
--   If this function has not previously been called for the given display,
--   a new icon theme object will be created and associated with the
--   display. Icon theme objects are fairly expensive to create, so using
--   this function is usually a better choice than calling
--   <a>iconThemeNew</a> and setting the display yourself; by using this
--   function a single icon theme object will be shared between users.
iconThemeGetForDisplay :: (HasCallStack, MonadIO m, IsDisplay a) => a -> m IconTheme

-- | Lists the names of icons in the current icon theme.
iconThemeGetIconNames :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m [Text]

-- | Returns an array of integers describing the sizes at which the icon is
--   available without scaling.
--   
--   A size of -1 means that the icon is available in a scalable format.
--   The array is zero-terminated.
iconThemeGetIconSizes :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m [Int32]

-- | Gets the current resource path.
--   
--   See <a>iconThemeSetResourcePath</a>.
iconThemeGetResourcePath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m (Maybe [Text])

-- | Gets the current search path.
--   
--   See <a>iconThemeSetSearchPath</a>.
iconThemeGetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m (Maybe [[Char]])

-- | Gets the current icon theme name.
iconThemeGetThemeName :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> m Text

-- | Checks whether an icon theme includes an icon for a particular
--   <tt>GIcon</tt>.
--   
--   <i>Since: 4.2</i>
iconThemeHasGicon :: (HasCallStack, MonadIO m, IsIconTheme a, IsIcon b) => a -> b -> m Bool

-- | Checks whether an icon theme includes an icon for a particular name.
iconThemeHasIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> m Bool

-- | Looks up a icon for a desired size and window scale.
--   
--   The icon can then be rendered by using it as a <tt>GdkPaintable</tt>,
--   or you can get information such as the filename and size.
iconThemeLookupByGicon :: (HasCallStack, MonadIO m, IsIconTheme a, IsIcon b) => a -> b -> Int32 -> Int32 -> TextDirection -> [IconLookupFlags] -> m IconPaintable

-- | Looks up a named icon for a desired size and window scale, returning a
--   <tt>GtkIconPaintable</tt>.
--   
--   The icon can then be rendered by using it as a <tt>GdkPaintable</tt>,
--   or you can get information such as the filename and size.
--   
--   If the available <i><tt>iconName</tt></i> is not available and
--   <i><tt>fallbacks</tt></i> are provided, they will be tried in order.
--   
--   If no matching icon is found, then a paintable that renders the
--   "missing icon" icon is returned. If you need to do something else for
--   missing icons you need to use <a>iconThemeHasIcon</a>.
--   
--   Note that you probably want to listen for icon theme changes and
--   update the icon. This is usually done by overriding the
--   GtkWidgetClass.css-<tt><i>changed()</i></tt> function.
iconThemeLookupIcon :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Text -> Maybe [Text] -> Int32 -> Int32 -> TextDirection -> [IconLookupFlags] -> m IconPaintable

-- | Creates a new icon theme object.
--   
--   Icon theme objects are used to lookup up an icon by name in a
--   particular icon theme. Usually, you’ll want to use
--   <a>iconThemeGetForDisplay</a> rather than creating a new icon theme
--   object for scratch.
iconThemeNew :: (HasCallStack, MonadIO m) => m IconTheme

-- | Sets the resource paths that will be looked at when looking for icons,
--   similar to search paths.
--   
--   The resources are considered as part of the hicolor icon theme and
--   must be located in subdirectories that are defined in the hicolor icon
--   theme, such as <tt>@path/16x16/actions/run.png</tt> or
--   <tt>@path/scalable/actions/run.svg</tt>.
--   
--   Icons that are directly placed in the resource path instead of a
--   subdirectory are also considered as ultimate fallback, but they are
--   treated like unthemed icons.
iconThemeSetResourcePath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe [Text] -> m ()

-- | Sets the search path for the icon theme object.
--   
--   When looking for an icon theme, GTK will search for a subdirectory of
--   one or more of the directories in <i><tt>path</tt></i> with the same
--   name as the icon theme containing an index.theme file. (Themes from
--   multiple of the path elements are combined to allow themes to be
--   extended by adding icons in the user’s home directory.)
--   
--   In addition if an icon found isn’t found either in the current icon
--   theme or the default icon theme, and an image file with the right name
--   is found directly in one of the elements of <i><tt>path</tt></i>, then
--   that image will be used for the icon name. (This is legacy feature,
--   and new icons should be put into the fallback icon theme, which is
--   called hicolor, rather than directly on the icon path.)
iconThemeSetSearchPath :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe [[Char]] -> m ()

-- | Sets the name of the icon theme that the <tt>GtkIconTheme</tt> object
--   uses overriding system configuration.
--   
--   This function cannot be called on the icon theme objects returned from
--   <a>iconThemeGetForDisplay</a>.
iconThemeSetThemeName :: (HasCallStack, MonadIO m, IsIconTheme a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>display</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #display
--   </pre>
clearIconThemeDisplay :: (MonadIO m, IsIconTheme o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>display</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconThemeDisplay :: (IsIconTheme o, MonadIO m, IsDisplay a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconTheme #display
--   </pre>
getIconThemeDisplay :: (MonadIO m, IsIconTheme o) => o -> m (Maybe Display)

-- | Set the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconTheme [ #display <a>:=</a> value ]
--   </pre>
setIconThemeDisplay :: (MonadIO m, IsIconTheme o, IsDisplay a) => o -> a -> m ()

-- | Get the value of the “<tt>icon-names</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconTheme #iconNames
--   </pre>
getIconThemeIconNames :: (MonadIO m, IsIconTheme o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>resource-path</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #resourcePath
--   </pre>
clearIconThemeResourcePath :: (MonadIO m, IsIconTheme o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resource-path</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconThemeResourcePath :: (IsIconTheme o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>resource-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconTheme #resourcePath
--   </pre>
getIconThemeResourcePath :: (MonadIO m, IsIconTheme o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>resource-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconTheme [ #resourcePath <a>:=</a> value ]
--   </pre>
setIconThemeResourcePath :: (MonadIO m, IsIconTheme o) => o -> [Text] -> m ()

-- | Set the value of the “<tt>search-path</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #searchPath
--   </pre>
clearIconThemeSearchPath :: (MonadIO m, IsIconTheme o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-path</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconThemeSearchPath :: (IsIconTheme o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>search-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconTheme #searchPath
--   </pre>
getIconThemeSearchPath :: (MonadIO m, IsIconTheme o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>search-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconTheme [ #searchPath <a>:=</a> value ]
--   </pre>
setIconThemeSearchPath :: (MonadIO m, IsIconTheme o) => o -> [Text] -> m ()

-- | Set the value of the “<tt>theme-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #themeName
--   </pre>
clearIconThemeThemeName :: (MonadIO m, IsIconTheme o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>theme-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructIconThemeThemeName :: (IsIconTheme o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconTheme #themeName
--   </pre>
getIconThemeThemeName :: (MonadIO m, IsIconTheme o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconTheme [ #themeName <a>:=</a> value ]
--   </pre>
setIconThemeThemeName :: (MonadIO m, IsIconTheme o) => o -> Text -> m ()

-- | Emitted when the icon theme changes.
--   
--   This can happen because current icon theme is switched or because GTK
--   detects that a change has occurred in the contents of the current icon
--   theme.
type IconThemeChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconTheme #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconThemeChanged :: (IsIconTheme a, MonadIO m) => a -> ((?self :: a) => IconThemeChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconTheme #changed callback
--   </pre>
onIconThemeChanged :: (IsIconTheme a, MonadIO m) => a -> ((?self :: a) => IconThemeChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.IconTheme.IconTheme
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.IconTheme.IconTheme
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.IconTheme.IconTheme
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.IconTheme.IconTheme)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.IconTheme.IconTheme o) => GI.Gtk.Objects.IconTheme.IsIconTheme o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.IconTheme.IconTheme
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.IconTheme.IconTheme


-- | Creates widgets for the items taken from a <tt>GListModel</tt>.
--   
--   This is one of the core concepts of handling list widgets such as
--   <a>ListView</a> or <a>GridView</a>.
--   
--   The <tt>GtkListItemFactory</tt> is tasked with creating widgets for
--   items taken from the model when the views need them and updating them
--   as the items displayed by the view change.
--   
--   A view is usually only able to display anything after both a factory
--   and a model have been set on the view. So it is important that you do
--   not skip this step when setting up your first view.
--   
--   Because views do not display the whole list at once but only a few
--   items, they only need to maintain a few widgets at a time. They will
--   instruct the <tt>GtkListItemFactory</tt> to create these widgets and
--   bind them to the items that are currently displayed.
--   
--   As the list model changes or the user scrolls to the list, the items
--   will change and the view will instruct the factory to bind the widgets
--   to those new items.
--   
--   The actual widgets used for displaying those widgets is provided by
--   you.
--   
--   When the factory needs widgets created, it will create a
--   <tt>GtkListItem</tt> and hand it to your code to set up a widget for.
--   This list item will provide various properties with information about
--   what item to display and provide you with some opportunities to
--   configure its behavior. See the <a>ListItem</a> documentation for
--   further details.
--   
--   Various implementations of <tt>GtkListItemFactory</tt> exist to allow
--   you different ways to provide those widgets. The most common
--   implementations are <a>BuilderListItemFactory</a> which takes a
--   <tt>GtkBuilder</tt> .ui file and then creates widgets and manages
--   everything automatically from the information in that file and
--   <a>SignalListItemFactory</a> which allows you to connect to signals
--   with your own code and retain full control over how the widgets are
--   setup and managed.
--   
--   A <tt>GtkListItemFactory</tt> is supposed to be final - that means its
--   behavior should not change and the first widget created from it should
--   behave the same way as the last widget created from it. If you intend
--   to do changes to the behavior, it is recommended that you create a new
--   <tt>GtkListItemFactory</tt> which will allow the views to recreate its
--   widgets.
--   
--   Once you have chosen your factory and created it, you need to set it
--   on the view widget you want to use it with, such as via
--   <a>listViewSetFactory</a>. Reusing factories across different views is
--   allowed, but very uncommon.
module GI.Gtk.Objects.ListItemFactory

-- | Memory-managed wrapper type.
newtype ListItemFactory
ListItemFactory :: ManagedPtr ListItemFactory -> ListItemFactory

-- | Type class for types which can be safely cast to
--   <a>ListItemFactory</a>, for instance with <a>toListItemFactory</a>.
class (GObject o, IsDescendantOf ListItemFactory o) => IsListItemFactory o

-- | Cast to <a>ListItemFactory</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toListItemFactory :: (MonadIO m, IsListItemFactory o) => o -> m ListItemFactory
instance GHC.Classes.Eq GI.Gtk.Objects.ListItemFactory.ListItemFactory
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListItemFactory.ListItemFactory
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListItemFactory.ListItemFactory
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListItemFactory.ListItemFactory)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListItemFactory.ListItemFactory o) => GI.Gtk.Objects.ListItemFactory.IsListItemFactory o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListItemFactory.ListItemFactory
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListItemFactory.ListItemFactory


-- | Creates widgets by instantiating <tt>GtkBuilder</tt> UI templates.
--   
--   The templates must extend the class that the parent widget expects.
--   For example, a factory provided to <a>ListView:factory</a> must have a
--   template that extends <a>ListItem</a>.
--   
--   Templates typically use <a>Expression</a> to obtain data from the
--   items in the model.
--   
--   Example:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;interface&gt;
--     &lt;template class="GtkListItem"&gt;
--       &lt;property name="child"&gt;
--         &lt;object class="GtkLabel"&gt;
--           &lt;property name="xalign"&gt;0&lt;/property&gt;
--           &lt;binding name="label"&gt;
--             &lt;lookup name="name" type="SettingsKey"&gt;
--               &lt;lookup name="item"&gt;GtkListItem&lt;/lookup&gt;
--             &lt;/lookup&gt;
--           &lt;/binding&gt;
--         &lt;/object&gt;
--       &lt;/property&gt;
--     &lt;/template&gt;
--   &lt;/interface&gt;
--   </pre>
--   
--   A common approach is to embed such templates as CDATA marked sections
--   into a surrounding UI file. Note that if you use this approach,
--   extracting translatable strings with xgettext will not work for
--   strings inside the marked section.
module GI.Gtk.Objects.BuilderListItemFactory

-- | Memory-managed wrapper type.
newtype BuilderListItemFactory
BuilderListItemFactory :: ManagedPtr BuilderListItemFactory -> BuilderListItemFactory

-- | Type class for types which can be safely cast to
--   <a>BuilderListItemFactory</a>, for instance with
--   <a>toBuilderListItemFactory</a>.
class (GObject o, IsDescendantOf BuilderListItemFactory o) => IsBuilderListItemFactory o

-- | Cast to <a>BuilderListItemFactory</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toBuilderListItemFactory :: (MonadIO m, IsBuilderListItemFactory o) => o -> m BuilderListItemFactory

-- | Gets the data used as the <tt>GtkBuilder</tt> UI template for
--   constructing listitems.
builderListItemFactoryGetBytes :: (HasCallStack, MonadIO m, IsBuilderListItemFactory a) => a -> m Bytes

-- | If the data references a resource, gets the path of that resource.
builderListItemFactoryGetResource :: (HasCallStack, MonadIO m, IsBuilderListItemFactory a) => a -> m (Maybe Text)

-- | Gets the scope used when constructing listitems.
builderListItemFactoryGetScope :: (HasCallStack, MonadIO m, IsBuilderListItemFactory a) => a -> m (Maybe BuilderScope)

-- | Creates a new <tt>GtkBuilderListItemFactory</tt> that instantiates
--   widgets using <i><tt>bytes</tt></i> as the data to pass to
--   <tt>GtkBuilder</tt>.
builderListItemFactoryNewFromBytes :: (HasCallStack, MonadIO m, IsBuilderScope a) => Maybe a -> Bytes -> m BuilderListItemFactory

-- | Creates a new <tt>GtkBuilderListItemFactory</tt> that instantiates
--   widgets using data read from the given <i><tt>resourcePath</tt></i> to
--   pass to <tt>GtkBuilder</tt>.
builderListItemFactoryNewFromResource :: (HasCallStack, MonadIO m, IsBuilderScope a) => Maybe a -> Text -> m BuilderListItemFactory

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>bytes</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBuilderListItemFactoryBytes :: (IsBuilderListItemFactory o, MonadIO m) => Bytes -> m (GValueConstruct o)

-- | Get the value of the “<tt>bytes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> builderListItemFactory #bytes
--   </pre>
getBuilderListItemFactoryBytes :: (MonadIO m, IsBuilderListItemFactory o) => o -> m Bytes

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resource</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructBuilderListItemFactoryResource :: (IsBuilderListItemFactory o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> builderListItemFactory #resource
--   </pre>
getBuilderListItemFactoryResource :: (MonadIO m, IsBuilderListItemFactory o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scope</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBuilderListItemFactoryScope :: (IsBuilderListItemFactory o, MonadIO m, IsBuilderScope a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>scope</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> builderListItemFactory #scope
--   </pre>
getBuilderListItemFactoryScope :: (MonadIO m, IsBuilderListItemFactory o) => o -> m (Maybe BuilderScope)
instance GHC.Classes.Eq GI.Gtk.Objects.BuilderListItemFactory.BuilderListItemFactory
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.BuilderListItemFactory.BuilderListItemFactory
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.BuilderListItemFactory.BuilderListItemFactory
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.BuilderListItemFactory.BuilderListItemFactory o) => GI.Gtk.Objects.BuilderListItemFactory.IsBuilderListItemFactory o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.BuilderListItemFactory.BuilderListItemFactory)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.BuilderListItemFactory.BuilderListItemFactory
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.BuilderListItemFactory.BuilderListItemFactory


-- | The integration point for media playback inside GTK.
--   
--   GTK provides an implementation of the <tt>GtkMediaStream</tt>
--   interface that is called <a>MediaFile</a>.
--   
--   Apart from application-facing API for stream playback,
--   <tt>GtkMediaStream</tt> has a number of APIs that are only useful for
--   implementations and should not be used in applications:
--   <a>MediaStream</a>.<tt><i>prepared</i></tt>(),
--   <a>MediaStream</a>.<tt><i>unprepared</i></tt>(),
--   <a>mediaStreamUpdate</a>, <a>MediaStream</a>.<tt><i>ended</i></tt>(),
--   <a>mediaStreamSeekSuccess</a>, <a>mediaStreamSeekFailed</a>,
--   <a>mediaStreamGerror</a>, <a>MediaStream</a>.<tt><i>error</i></tt>(),
--   <a>MediaStream</a>.<tt><i>error_valist</i></tt>().
module GI.Gtk.Objects.MediaStream

-- | Memory-managed wrapper type.
newtype MediaStream
MediaStream :: ManagedPtr MediaStream -> MediaStream

-- | Type class for types which can be safely cast to <a>MediaStream</a>,
--   for instance with <a>toMediaStream</a>.
class (GObject o, IsDescendantOf MediaStream o) => IsMediaStream o

-- | Cast to <a>MediaStream</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMediaStream :: (MonadIO m, IsMediaStream o) => o -> m MediaStream

-- | Sets <i><tt>self</tt></i> into an error state.
--   
--   This will pause the stream (you can check for an error via
--   <a>mediaStreamGetError</a> in your
--   GtkMediaStream.<tt><i>pause()</i></tt> implementation), abort pending
--   seeks and mark the stream as prepared.
--   
--   if the stream is already in an error state, this call will be ignored
--   and the existing error will be retained.
--   
--   To unset an error, the stream must be reset via a call to
--   <a>MediaStream</a>.<tt><i>unprepared</i></tt>().
mediaStreamGerror :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> GError -> m ()

-- | Gets the duration of the stream.
--   
--   If the duration is not known, 0 will be returned.
mediaStreamGetDuration :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Int64

-- | Returns whether the streams playback is finished.
mediaStreamGetEnded :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | If the stream is in an error state, returns the <tt>GError</tt>
--   explaining that state.
--   
--   Any type of error can be reported here depending on the implementation
--   of the media stream.
--   
--   A media stream in an error cannot be operated on, calls like
--   <a>mediaStreamPlay</a> or <a>mediaStreamSeek</a> will not have any
--   effect.
--   
--   <tt>GtkMediaStream</tt> itself does not provide a way to unset an
--   error, but implementations may provide options. For example, a
--   <a>MediaFile</a> will unset errors when a new source is set, e.g. with
--   <a>mediaFileSetFile</a>.
mediaStreamGetError :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m (Maybe GError)

-- | Returns whether the stream is set to loop.
--   
--   See <a>mediaStreamSetLoop</a> for details.
mediaStreamGetLoop :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Returns whether the audio for the stream is muted.
--   
--   See <a>mediaStreamSetMuted</a> for details.
mediaStreamGetMuted :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Return whether the stream is currently playing.
mediaStreamGetPlaying :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Returns the current presentation timestamp in microseconds.
mediaStreamGetTimestamp :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Int64

-- | Returns the volume of the audio for the stream.
--   
--   See <a>mediaStreamSetVolume</a> for details.
mediaStreamGetVolume :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Double

-- | Returns whether the stream has audio.
mediaStreamHasAudio :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Returns whether the stream has video.
mediaStreamHasVideo :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Returns whether the stream has finished initializing.
--   
--   At this point the existence of audio and video is known.
mediaStreamIsPrepared :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Checks if a stream may be seekable.
--   
--   This is meant to be a hint. Streams may not allow seeking even if this
--   function returns <a>True</a>. However, if this function returns
--   <a>False</a>, streams are guaranteed to not be seekable and user
--   interfaces may hide controls that allow seeking.
--   
--   It is allowed to call <a>mediaStreamSeek</a> on a non-seekable stream,
--   though it will not do anything.
mediaStreamIsSeekable :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Checks if there is currently a seek operation going on.
mediaStreamIsSeeking :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m Bool

-- | Pauses playback of the stream.
--   
--   If the stream is not playing, do nothing.
mediaStreamPause :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m ()

-- | Starts playing the stream.
--   
--   If the stream is in error or already playing, do nothing.
mediaStreamPlay :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m ()

-- | Called by users to attach the media stream to a <tt>GdkSurface</tt>
--   they manage.
--   
--   The stream can then access the resources of <i><tt>surface</tt></i>
--   for its rendering purposes. In particular, media streams might want to
--   create a <tt>GdkGLContext</tt> or sync to the <tt>GdkFrameClock</tt>.
--   
--   Whoever calls this function is responsible for calling
--   <a>mediaStreamUnrealize</a> before either the stream or
--   <i><tt>surface</tt></i> get destroyed.
--   
--   Multiple calls to this function may happen from different users of the
--   video, even with the same <i><tt>surface</tt></i>. Each of these calls
--   must be followed by its own call to <a>mediaStreamUnrealize</a>.
--   
--   It is not required to call this function to make a media stream work.
mediaStreamRealize :: (HasCallStack, MonadIO m, IsMediaStream a, IsSurface b) => a -> b -> m ()

-- | Start a seek operation on <i><tt>self</tt></i> to
--   <i><tt>timestamp</tt></i>.
--   
--   If <i><tt>timestamp</tt></i> is out of range, it will be clamped.
--   
--   Seek operations may not finish instantly. While a seek operation is in
--   process, the <a>MediaStream:seeking</a> property will be set.
--   
--   When calling <a>mediaStreamSeek</a> during an ongoing seek operation,
--   the new seek will override any pending seek.
mediaStreamSeek :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> Int64 -> m ()

-- | Ends a seek operation started via
--   GtkMediaStream.<tt><i>seek()</i></tt> as a failure.
--   
--   This will not cause an error on the stream and will assume that
--   playback continues as if no seek had happened.
--   
--   See <a>mediaStreamSeekSuccess</a> for the other way of ending a seek.
mediaStreamSeekFailed :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m ()

-- | Ends a seek operation started via
--   GtkMediaStream.<tt><i>seek()</i></tt> successfully.
--   
--   This function will unset the GtkMediaStream:ended property if it was
--   set.
--   
--   See <a>mediaStreamSeekFailed</a> for the other way of ending a seek.
mediaStreamSeekSuccess :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m ()

-- | Sets whether the stream should loop.
--   
--   In this case, it will attempt to restart playback from the beginning
--   instead of stopping at the end.
--   
--   Not all streams may support looping, in particular non-seekable
--   streams. Those streams will ignore the loop setting and just end.
mediaStreamSetLoop :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> Bool -> m ()

-- | Sets whether the audio stream should be muted.
--   
--   Muting a stream will cause no audio to be played, but it does not
--   modify the volume. This means that muting and then unmuting the stream
--   will restore the volume settings.
--   
--   If the stream has no audio, calling this function will still work but
--   it will not have an audible effect.
mediaStreamSetMuted :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> Bool -> m ()

-- | Starts or pauses playback of the stream.
mediaStreamSetPlaying :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> Bool -> m ()

-- | Sets the volume of the audio stream.
--   
--   This function call will work even if the stream is muted.
--   
--   The given <i><tt>volume</tt></i> should range from 0.0 for silence to
--   1.0 for as loud as possible. Values outside of this range will be
--   clamped to the nearest value.
--   
--   If the stream has no audio or is muted, calling this function will
--   still work but it will not have an immediate audible effect. When the
--   stream is unmuted, the new volume setting will take effect.
mediaStreamSetVolume :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> Double -> m ()

-- | Pauses the media stream and marks it as ended.
--   
--   This is a hint only, calls to <a>mediaStreamPlay</a> may still happen.
--   
--   The media stream must be prepared when this function is called.
--   
--   <i>Since: 4.4</i>
mediaStreamStreamEnded :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m ()

-- | Called by <tt>GtkMediaStream</tt> implementations to advertise the
--   stream being ready to play and providing details about the stream.
--   
--   Note that the arguments are hints. If the stream implementation cannot
--   determine the correct values, it is better to err on the side of
--   caution and return <a>True</a>. User interfaces will use those values
--   to determine what controls to show.
--   
--   This function may not be called again until the stream has been reset
--   via <a>mediaStreamStreamUnprepared</a>.
--   
--   <i>Since: 4.4</i>
mediaStreamStreamPrepared :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> Bool -> Bool -> Bool -> Int64 -> m ()

-- | Resets a given media stream implementation.
--   
--   <a>mediaStreamStreamPrepared</a> can then be called again.
--   
--   This function will also reset any error state the stream was in.
--   
--   <i>Since: 4.4</i>
mediaStreamStreamUnprepared :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> m ()

-- | Undoes a previous call to <a>mediaStreamRealize</a>.
--   
--   This causes the stream to release all resources it had allocated from
--   <i><tt>surface</tt></i>.
mediaStreamUnrealize :: (HasCallStack, MonadIO m, IsMediaStream a, IsSurface b) => a -> b -> m ()

-- | Media stream implementations should regularly call this function to
--   update the timestamp reported by the stream.
--   
--   It is up to implementations to call this at the frequency they deem
--   appropriate.
--   
--   The media stream must be prepared when this function is called.
mediaStreamUpdate :: (HasCallStack, MonadIO m, IsMediaStream a) => a -> Int64 -> m ()

-- | Get the value of the “<tt>duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #duration
--   </pre>
getMediaStreamDuration :: (MonadIO m, IsMediaStream o) => o -> m Int64

-- | Get the value of the “<tt>ended</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #ended
--   </pre>
getMediaStreamEnded :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Get the value of the “<tt>error</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #error
--   </pre>
getMediaStreamError :: (MonadIO m, IsMediaStream o) => o -> m (Maybe GError)

-- | Get the value of the “<tt>has-audio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #hasAudio
--   </pre>
getMediaStreamHasAudio :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Get the value of the “<tt>has-video</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #hasVideo
--   </pre>
getMediaStreamHasVideo :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>loop</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMediaStreamLoop :: (IsMediaStream o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>loop</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #loop
--   </pre>
getMediaStreamLoop :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Set the value of the “<tt>loop</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mediaStream [ #loop <a>:=</a> value ]
--   </pre>
setMediaStreamLoop :: (MonadIO m, IsMediaStream o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>muted</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMediaStreamMuted :: (IsMediaStream o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>muted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #muted
--   </pre>
getMediaStreamMuted :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Set the value of the “<tt>muted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mediaStream [ #muted <a>:=</a> value ]
--   </pre>
setMediaStreamMuted :: (MonadIO m, IsMediaStream o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>playing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMediaStreamPlaying :: (IsMediaStream o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>playing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #playing
--   </pre>
getMediaStreamPlaying :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Set the value of the “<tt>playing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mediaStream [ #playing <a>:=</a> value ]
--   </pre>
setMediaStreamPlaying :: (MonadIO m, IsMediaStream o) => o -> Bool -> m ()

-- | Get the value of the “<tt>prepared</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #prepared
--   </pre>
getMediaStreamPrepared :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Get the value of the “<tt>seekable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #seekable
--   </pre>
getMediaStreamSeekable :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Get the value of the “<tt>seeking</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #seeking
--   </pre>
getMediaStreamSeeking :: (MonadIO m, IsMediaStream o) => o -> m Bool

-- | Get the value of the “<tt>timestamp</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #timestamp
--   </pre>
getMediaStreamTimestamp :: (MonadIO m, IsMediaStream o) => o -> m Int64

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>volume</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMediaStreamVolume :: (IsMediaStream o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>volume</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaStream #volume
--   </pre>
getMediaStreamVolume :: (MonadIO m, IsMediaStream o) => o -> m Double

-- | Set the value of the “<tt>volume</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mediaStream [ #volume <a>:=</a> value ]
--   </pre>
setMediaStreamVolume :: (MonadIO m, IsMediaStream o) => o -> Double -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.MediaStream.MediaStream
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MediaStream.MediaStream
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MediaStream.MediaStream
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MediaStream.MediaStream)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MediaStream.MediaStream o) => GI.Gtk.Objects.MediaStream.IsMediaStream o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MediaStream.MediaStream
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MediaStream.MediaStream


-- | Implements the <tt>GtkMediaStream</tt> interface for files.
--   
--   This provides a simple way to play back video files with GTK.
--   
--   GTK provides a GIO extension point for <tt>GtkMediaFile</tt>
--   implementations to allow for external implementations using various
--   media frameworks.
--   
--   GTK itself includes an implementation using GStreamer.
module GI.Gtk.Objects.MediaFile

-- | Memory-managed wrapper type.
newtype MediaFile
MediaFile :: ManagedPtr MediaFile -> MediaFile

-- | Type class for types which can be safely cast to <a>MediaFile</a>, for
--   instance with <a>toMediaFile</a>.
class (GObject o, IsDescendantOf MediaFile o) => IsMediaFile o

-- | Cast to <a>MediaFile</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMediaFile :: (MonadIO m, IsMediaFile o) => o -> m MediaFile

-- | Resets the media file to be empty.
mediaFileClear :: (HasCallStack, MonadIO m, IsMediaFile a) => a -> m ()

-- | Returns the file that <i><tt>self</tt></i> is currently playing from.
--   
--   When <i><tt>self</tt></i> is not playing or not playing from a file,
--   <a>Nothing</a> is returned.
mediaFileGetFile :: (HasCallStack, MonadIO m, IsMediaFile a) => a -> m (Maybe File)

-- | Returns the stream that <i><tt>self</tt></i> is currently playing
--   from.
--   
--   When <i><tt>self</tt></i> is not playing or not playing from a stream,
--   <a>Nothing</a> is returned.
mediaFileGetInputStream :: (HasCallStack, MonadIO m, IsMediaFile a) => a -> m (Maybe InputStream)

-- | Creates a new empty media file.
mediaFileNew :: (HasCallStack, MonadIO m) => m MediaFile

-- | Creates a new media file to play <i><tt>file</tt></i>.
mediaFileNewForFile :: (HasCallStack, MonadIO m, IsFile a) => a -> m MediaFile

-- | Creates a new media file for the given filename.
--   
--   This is a utility function that converts the given
--   <i><tt>filename</tt></i> to a <tt>GFile</tt> and calls
--   <a>mediaFileNewForFile</a>.
mediaFileNewForFilename :: (HasCallStack, MonadIO m) => [Char] -> m MediaFile

-- | Creates a new media file to play <i><tt>stream</tt></i>.
--   
--   If you want the resulting media to be seekable, the stream should
--   implement the <tt>GSeekable</tt> interface.
mediaFileNewForInputStream :: (HasCallStack, MonadIO m, IsInputStream a) => a -> m MediaFile

-- | Creates a new new media file for the given resource.
--   
--   This is a utility function that converts the given
--   <i><tt>resource</tt></i> to a <tt>GFile</tt> and calls
--   <a>mediaFileNewForFile</a>.
mediaFileNewForResource :: (HasCallStack, MonadIO m) => Text -> m MediaFile

-- | Sets the <tt>GtkMediaFile</tt> to play the given file.
--   
--   If any file is still playing, stop playing it.
mediaFileSetFile :: (HasCallStack, MonadIO m, IsMediaFile a, IsFile b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkMediaFile</tt> to play the given file.
--   
--   This is a utility function that converts the given
--   <i><tt>filename</tt></i> to a <tt>GFile</tt> and calls
--   <a>mediaFileSetFile</a>.
mediaFileSetFilename :: (HasCallStack, MonadIO m, IsMediaFile a) => a -> Maybe [Char] -> m ()

-- | Sets the <tt>GtkMediaFile</tt> to play the given stream.
--   
--   If anything is still playing, stop playing it.
--   
--   Full control about the <i><tt>stream</tt></i> is assumed for the
--   duration of playback. The stream will not be closed.
mediaFileSetInputStream :: (HasCallStack, MonadIO m, IsMediaFile a, IsInputStream b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkMediaFile</tt> to play the given resource.
--   
--   This is a utility function that converts the given
--   <i><tt>resourcePath</tt></i> to a <tt>GFile</tt> and calls
--   <a>mediaFileSetFile</a>.
mediaFileSetResource :: (HasCallStack, MonadIO m, IsMediaFile a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearMediaFileFile :: (MonadIO m, IsMediaFile o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMediaFileFile :: (IsMediaFile o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaFile #file
--   </pre>
getMediaFileFile :: (MonadIO m, IsMediaFile o) => o -> m (Maybe File)

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mediaFile [ #file <a>:=</a> value ]
--   </pre>
setMediaFileFile :: (MonadIO m, IsMediaFile o, IsFile a) => o -> a -> m ()

-- | Set the value of the “<tt>input-stream</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #inputStream
--   </pre>
clearMediaFileInputStream :: (MonadIO m, IsMediaFile o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-stream</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMediaFileInputStream :: (IsMediaFile o, MonadIO m, IsInputStream a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-stream</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaFile #inputStream
--   </pre>
getMediaFileInputStream :: (MonadIO m, IsMediaFile o) => o -> m (Maybe InputStream)

-- | Set the value of the “<tt>input-stream</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mediaFile [ #inputStream <a>:=</a> value ]
--   </pre>
setMediaFileInputStream :: (MonadIO m, IsMediaFile o, IsInputStream a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.MediaFile.MediaFile
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MediaFile.MediaFile
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MediaFile.MediaFile
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MediaFile.MediaFile)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MediaFile.MediaFile o) => GI.Gtk.Objects.MediaFile.IsMediaFile o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MediaFile.MediaFile
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MediaFile.MediaFile


-- | Base class for filters that combine multiple filters.
module GI.Gtk.Objects.MultiFilter

-- | Memory-managed wrapper type.
newtype MultiFilter
MultiFilter :: ManagedPtr MultiFilter -> MultiFilter

-- | Type class for types which can be safely cast to <a>MultiFilter</a>,
--   for instance with <a>toMultiFilter</a>.
class (GObject o, IsDescendantOf MultiFilter o) => IsMultiFilter o

-- | Cast to <a>MultiFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMultiFilter :: (MonadIO m, IsMultiFilter o) => o -> m MultiFilter

-- | Adds a filter.
multiFilterAppend :: (HasCallStack, MonadIO m, IsMultiFilter a, IsFilter b) => a -> b -> m ()

-- | Removes a filter.
--   
--   If <i><tt>position</tt></i> is larger than the number of filters,
--   nothing happens.
multiFilterRemove :: (HasCallStack, MonadIO m, IsMultiFilter a) => a -> Word32 -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> multiFilter #itemType
--   </pre>
getMultiFilterItemType :: (MonadIO m, IsMultiFilter o) => o -> m GType

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> multiFilter #nItems
--   </pre>
getMultiFilterNItems :: (MonadIO m, IsMultiFilter o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.MultiFilter.MultiFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MultiFilter.MultiFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MultiFilter.MultiFilter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MultiFilter.MultiFilter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MultiFilter.MultiFilter o) => GI.Gtk.Objects.MultiFilter.IsMultiFilter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MultiFilter.MultiFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MultiFilter.MultiFilter


-- | Matches an item when each of its filters matches.
--   
--   To add filters to a <tt>GtkEveryFilter</tt>, use
--   <a>multiFilterAppend</a>.
module GI.Gtk.Objects.EveryFilter

-- | Memory-managed wrapper type.
newtype EveryFilter
EveryFilter :: ManagedPtr EveryFilter -> EveryFilter

-- | Type class for types which can be safely cast to <a>EveryFilter</a>,
--   for instance with <a>toEveryFilter</a>.
class (GObject o, IsDescendantOf EveryFilter o) => IsEveryFilter o

-- | Cast to <a>EveryFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toEveryFilter :: (MonadIO m, IsEveryFilter o) => o -> m EveryFilter

-- | Creates a new empty "every" filter.
--   
--   Use <a>multiFilterAppend</a> to add filters to it.
--   
--   This filter matches an item if each of the filters added to it matches
--   the item. In particular, this means that if no filter has been added
--   to it, the filter matches every item.
everyFilterNew :: (HasCallStack, MonadIO m) => m EveryFilter
instance GHC.Classes.Eq GI.Gtk.Objects.EveryFilter.EveryFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EveryFilter.EveryFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EveryFilter.EveryFilter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EveryFilter.EveryFilter o) => GI.Gtk.Objects.EveryFilter.IsEveryFilter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EveryFilter.EveryFilter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EveryFilter.EveryFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EveryFilter.EveryFilter


-- | Matches an item when at least one of its filters matches.
--   
--   To add filters to a <tt>GtkAnyFilter</tt>, use
--   <a>multiFilterAppend</a>.
module GI.Gtk.Objects.AnyFilter

-- | Memory-managed wrapper type.
newtype AnyFilter
AnyFilter :: ManagedPtr AnyFilter -> AnyFilter

-- | Type class for types which can be safely cast to <a>AnyFilter</a>, for
--   instance with <a>toAnyFilter</a>.
class (GObject o, IsDescendantOf AnyFilter o) => IsAnyFilter o

-- | Cast to <a>AnyFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAnyFilter :: (MonadIO m, IsAnyFilter o) => o -> m AnyFilter

-- | Creates a new empty "any" filter.
--   
--   Use <a>multiFilterAppend</a> to add filters to it.
--   
--   This filter matches an item if any of the filters added to it matches
--   the item. In particular, this means that if no filter has been added
--   to it, the filter matches no item.
anyFilterNew :: (HasCallStack, MonadIO m) => m AnyFilter
instance GHC.Classes.Eq GI.Gtk.Objects.AnyFilter.AnyFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AnyFilter.AnyFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AnyFilter.AnyFilter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AnyFilter.AnyFilter o) => GI.Gtk.Objects.AnyFilter.IsAnyFilter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AnyFilter.AnyFilter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AnyFilter.AnyFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AnyFilter.AnyFilter


-- | A <tt>GParamSpec</tt> for properties holding a <tt>GtkExpression</tt>.
module GI.Gtk.Objects.ParamSpecExpression

-- | Memory-managed wrapper type.
newtype ParamSpecExpression
ParamSpecExpression :: ManagedPtr ParamSpecExpression -> ParamSpecExpression

-- | Type class for types which can be safely cast to
--   <a>ParamSpecExpression</a>, for instance with
--   <a>toParamSpecExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecExpression o) => IsParamSpecExpression o

-- | Cast to <a>ParamSpecExpression</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toParamSpecExpression :: (MonadIO m, IsParamSpecExpression o) => o -> m ParamSpecExpression
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.ParamSpecExpression.ParamSpecExpression
instance GHC.Classes.Eq GI.Gtk.Objects.ParamSpecExpression.ParamSpecExpression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ParamSpecExpression.ParamSpecExpression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ParamSpecExpression.ParamSpecExpression o) => GI.Gtk.Objects.ParamSpecExpression.IsParamSpecExpression o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ParamSpecExpression.ParamSpecExpression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ParamSpecExpression.ParamSpecExpression


-- | A <tt>GtkEntryBuffer</tt> that locks the underlying memory to prevent
--   it from being swapped to disk.
--   
--   <tt>GtkPasswordEntry</tt> uses a <tt>GtkPasswordEntryBuffer</tt>.
--   
--   <i>Since: 4.4</i>
module GI.Gtk.Objects.PasswordEntryBuffer

-- | Memory-managed wrapper type.
newtype PasswordEntryBuffer
PasswordEntryBuffer :: ManagedPtr PasswordEntryBuffer -> PasswordEntryBuffer

-- | Type class for types which can be safely cast to
--   <a>PasswordEntryBuffer</a>, for instance with
--   <a>toPasswordEntryBuffer</a>.
class (GObject o, IsDescendantOf PasswordEntryBuffer o) => IsPasswordEntryBuffer o

-- | Cast to <a>PasswordEntryBuffer</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toPasswordEntryBuffer :: (MonadIO m, IsPasswordEntryBuffer o) => o -> m PasswordEntryBuffer

-- | Creates a new <tt>GtkEntryBuffer</tt> using secure memory allocations.
passwordEntryBufferNew :: (HasCallStack, MonadIO m) => m PasswordEntryBuffer
instance GHC.Classes.Eq GI.Gtk.Objects.PasswordEntryBuffer.PasswordEntryBuffer
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PasswordEntryBuffer.PasswordEntryBuffer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PasswordEntryBuffer.PasswordEntryBuffer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PasswordEntryBuffer.PasswordEntryBuffer)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PasswordEntryBuffer.PasswordEntryBuffer o) => GI.Gtk.Objects.PasswordEntryBuffer.IsPasswordEntryBuffer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PasswordEntryBuffer.PasswordEntryBuffer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PasswordEntryBuffer.PasswordEntryBuffer


-- | Provides a mechanism to share global settings between applications.
--   
--   GTK relies on the platform-specific API for getting desktop-wide
--   settings.
--   
--   On Wayland, the settings are obtained via a settings portal that is
--   part of the Linux desktop APIs for application.
--   
--   On the X window system, this sharing is realized by an
--   <a>XSettings</a> manager.
--   
--   On macOS, the settings are obtained from <tt>NSUserDefaults</tt>.
--   
--   In the absence of these sharing mechanisms, GTK reads default values
--   for settings from <tt>settings.ini</tt> files in
--   <tt>/etc/gtk-4.0</tt>, <tt>$XDG_CONFIG_DIRS/gtk-4.0</tt> and
--   <tt>$XDG_CONFIG_HOME/gtk-4.0</tt>. These files must be valid key files
--   (see <tt>GKeyFile</tt>), and have a section called Settings. Themes
--   can also provide default values for settings by installing a
--   <tt>settings.ini</tt> file next to their <tt>gtk.css</tt> file.
--   
--   Applications can override system-wide settings by setting the property
--   of the <tt>GtkSettings</tt> object with
--   <tt><i>g_object_set()</i></tt>. This should be restricted to special
--   cases though; <tt>GtkSettings</tt> are not meant as an application
--   configuration facility.
--   
--   There is one <tt>GtkSettings</tt> instance per display. It can be
--   obtained with <a>settingsGetForDisplay</a>, but in many cases, it is
--   more convenient to use <a>widgetGetSettings</a>.
module GI.Gtk.Objects.Settings

-- | Memory-managed wrapper type.
newtype Settings
Settings :: ManagedPtr Settings -> Settings

-- | Type class for types which can be safely cast to <a>Settings</a>, for
--   instance with <a>toSettings</a>.
class (GObject o, IsDescendantOf Settings o) => IsSettings o

-- | Cast to <a>Settings</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSettings :: (MonadIO m, IsSettings o) => o -> m Settings

-- | Gets the <tt>GtkSettings</tt> object for the default display, creating
--   it if necessary.
--   
--   See <a>settingsGetForDisplay</a>.
settingsGetDefault :: (HasCallStack, MonadIO m) => m (Maybe Settings)

-- | Gets the <tt>GtkSettings</tt> object for <i><tt>display</tt></i>,
--   creating it if necessary.
settingsGetForDisplay :: (HasCallStack, MonadIO m, IsDisplay a) => a -> m Settings

-- | Undoes the effect of calling <tt><i>g_object_set()</i></tt> to install
--   an application-specific value for a setting.
--   
--   After this call, the setting will again follow the session-wide value
--   for this setting.
settingsResetProperty :: (HasCallStack, MonadIO m, IsSettings a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-alternative-button-order</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkAlternativeButtonOrder :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-alternative-button-order</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkAlternativeButtonOrder
--   </pre>
getSettingsGtkAlternativeButtonOrder :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-alternative-button-order</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkAlternativeButtonOrder <a>:=</a> value ]
--   </pre>
setSettingsGtkAlternativeButtonOrder :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-alternative-sort-arrows</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkAlternativeSortArrows :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-alternative-sort-arrows</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkAlternativeSortArrows
--   </pre>
getSettingsGtkAlternativeSortArrows :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-alternative-sort-arrows</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkAlternativeSortArrows <a>:=</a> value ]
--   </pre>
setSettingsGtkAlternativeSortArrows :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-application-prefer-dark-theme</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkApplicationPreferDarkTheme :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-application-prefer-dark-theme</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkApplicationPreferDarkTheme
--   </pre>
getSettingsGtkApplicationPreferDarkTheme :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-application-prefer-dark-theme</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkApplicationPreferDarkTheme <a>:=</a> value ]
--   </pre>
setSettingsGtkApplicationPreferDarkTheme :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-aspect-ratio</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorAspectRatio :: (IsSettings o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-aspect-ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorAspectRatio
--   </pre>
getSettingsGtkCursorAspectRatio :: (MonadIO m, IsSettings o) => o -> m Double

-- | Set the value of the “<tt>gtk-cursor-aspect-ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorAspectRatio <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorAspectRatio :: (MonadIO m, IsSettings o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-blink</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkCursorBlink :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-blink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorBlink
--   </pre>
getSettingsGtkCursorBlink :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-cursor-blink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorBlink <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorBlink :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-blink-time</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorBlinkTime :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-blink-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorBlinkTime
--   </pre>
getSettingsGtkCursorBlinkTime :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-cursor-blink-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorBlinkTime <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorBlinkTime :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-blink-timeout</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorBlinkTimeout :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-blink-timeout</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorBlinkTimeout
--   </pre>
getSettingsGtkCursorBlinkTimeout :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-cursor-blink-timeout</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorBlinkTimeout <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorBlinkTimeout :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>gtk-cursor-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkCursorThemeName
--   </pre>
clearSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-theme-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorThemeName
--   </pre>
getSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-cursor-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-cursor-theme-size</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkCursorThemeSize :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-cursor-theme-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkCursorThemeSize
--   </pre>
getSettingsGtkCursorThemeSize :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-cursor-theme-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkCursorThemeSize <a>:=</a> value ]
--   </pre>
setSettingsGtkCursorThemeSize :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>gtk-decoration-layout</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkDecorationLayout
--   </pre>
clearSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-decoration-layout</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDecorationLayout :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDecorationLayout
--   </pre>
getSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDecorationLayout <a>:=</a> value ]
--   </pre>
setSettingsGtkDecorationLayout :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-dialogs-use-header</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDialogsUseHeader :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-dialogs-use-header</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDialogsUseHeader
--   </pre>
getSettingsGtkDialogsUseHeader :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-dialogs-use-header</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDialogsUseHeader <a>:=</a> value ]
--   </pre>
setSettingsGtkDialogsUseHeader :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-dnd-drag-threshold</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDndDragThreshold :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-dnd-drag-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDndDragThreshold
--   </pre>
getSettingsGtkDndDragThreshold :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-dnd-drag-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDndDragThreshold <a>:=</a> value ]
--   </pre>
setSettingsGtkDndDragThreshold :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-double-click-distance</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDoubleClickDistance :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-double-click-distance</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDoubleClickDistance
--   </pre>
getSettingsGtkDoubleClickDistance :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-double-click-distance</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDoubleClickDistance <a>:=</a> value ]
--   </pre>
setSettingsGtkDoubleClickDistance :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-double-click-time</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkDoubleClickTime :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-double-click-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkDoubleClickTime
--   </pre>
getSettingsGtkDoubleClickTime :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-double-click-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkDoubleClickTime <a>:=</a> value ]
--   </pre>
setSettingsGtkDoubleClickTime :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-accels</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkEnableAccels :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-accels</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableAccels
--   </pre>
getSettingsGtkEnableAccels :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-accels</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableAccels <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableAccels :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-animations</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnableAnimations :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-animations</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableAnimations
--   </pre>
getSettingsGtkEnableAnimations :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-animations</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableAnimations <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableAnimations :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-event-sounds</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnableEventSounds :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-event-sounds</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableEventSounds
--   </pre>
getSettingsGtkEnableEventSounds :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-event-sounds</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableEventSounds <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableEventSounds :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-input-feedback-sounds</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkEnableInputFeedbackSounds :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-input-feedback-sounds</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnableInputFeedbackSounds
--   </pre>
getSettingsGtkEnableInputFeedbackSounds :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-input-feedback-sounds</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnableInputFeedbackSounds <a>:=</a> value ]
--   </pre>
setSettingsGtkEnableInputFeedbackSounds :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-enable-primary-paste</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEnablePrimaryPaste :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-enable-primary-paste</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEnablePrimaryPaste
--   </pre>
getSettingsGtkEnablePrimaryPaste :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-enable-primary-paste</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEnablePrimaryPaste <a>:=</a> value ]
--   </pre>
setSettingsGtkEnablePrimaryPaste :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-entry-password-hint-timeout</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkEntryPasswordHintTimeout :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-entry-password-hint-timeout</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEntryPasswordHintTimeout
--   </pre>
getSettingsGtkEntryPasswordHintTimeout :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “<tt>gtk-entry-password-hint-timeout</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEntryPasswordHintTimeout <a>:=</a> value ]
--   </pre>
setSettingsGtkEntryPasswordHintTimeout :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-entry-select-on-focus</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkEntrySelectOnFocus :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-entry-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkEntrySelectOnFocus
--   </pre>
getSettingsGtkEntrySelectOnFocus :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-entry-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkEntrySelectOnFocus <a>:=</a> value ]
--   </pre>
setSettingsGtkEntrySelectOnFocus :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-error-bell</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkErrorBell :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-error-bell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkErrorBell
--   </pre>
getSettingsGtkErrorBell :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-error-bell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkErrorBell <a>:=</a> value ]
--   </pre>
setSettingsGtkErrorBell :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Set the value of the “<tt>gtk-font-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkFontName
--   </pre>
clearSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-font-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkFontName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkFontName
--   </pre>
getSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-font-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkFontName <a>:=</a> value ]
--   </pre>
setSettingsGtkFontName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-font-rendering</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkFontRendering :: (IsSettings o, MonadIO m) => FontRendering -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-font-rendering</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkFontRendering
--   </pre>
getSettingsGtkFontRendering :: (MonadIO m, IsSettings o) => o -> m FontRendering

-- | Set the value of the “<tt>gtk-font-rendering</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkFontRendering <a>:=</a> value ]
--   </pre>
setSettingsGtkFontRendering :: (MonadIO m, IsSettings o) => o -> FontRendering -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-fontconfig-timestamp</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkFontconfigTimestamp :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-fontconfig-timestamp</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkFontconfigTimestamp
--   </pre>
getSettingsGtkFontconfigTimestamp :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “<tt>gtk-fontconfig-timestamp</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkFontconfigTimestamp <a>:=</a> value ]
--   </pre>
setSettingsGtkFontconfigTimestamp :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-hint-font-metrics</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkHintFontMetrics :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-hint-font-metrics</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkHintFontMetrics
--   </pre>
getSettingsGtkHintFontMetrics :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-hint-font-metrics</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkHintFontMetrics <a>:=</a> value ]
--   </pre>
setSettingsGtkHintFontMetrics :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Set the value of the “<tt>gtk-icon-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkIconThemeName
--   </pre>
clearSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-icon-theme-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkIconThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-icon-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkIconThemeName
--   </pre>
getSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-icon-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkIconThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkIconThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Set the value of the “<tt>gtk-im-module</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkImModule
--   </pre>
clearSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-im-module</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkImModule :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkImModule
--   </pre>
getSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkImModule <a>:=</a> value ]
--   </pre>
setSettingsGtkImModule :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-interface-color-scheme</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkInterfaceColorScheme :: (IsSettings o, MonadIO m) => InterfaceColorScheme -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-interface-color-scheme</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkInterfaceColorScheme
--   </pre>
getSettingsGtkInterfaceColorScheme :: (MonadIO m, IsSettings o) => o -> m InterfaceColorScheme

-- | Set the value of the “<tt>gtk-interface-color-scheme</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkInterfaceColorScheme <a>:=</a> value ]
--   </pre>
setSettingsGtkInterfaceColorScheme :: (MonadIO m, IsSettings o) => o -> InterfaceColorScheme -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-interface-contrast</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkInterfaceContrast :: (IsSettings o, MonadIO m) => InterfaceContrast -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-interface-contrast</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkInterfaceContrast
--   </pre>
getSettingsGtkInterfaceContrast :: (MonadIO m, IsSettings o) => o -> m InterfaceContrast

-- | Set the value of the “<tt>gtk-interface-contrast</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkInterfaceContrast <a>:=</a> value ]
--   </pre>
setSettingsGtkInterfaceContrast :: (MonadIO m, IsSettings o) => o -> InterfaceContrast -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-interface-reduced-motion</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkInterfaceReducedMotion :: (IsSettings o, MonadIO m) => ReducedMotion -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-interface-reduced-motion</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkInterfaceReducedMotion
--   </pre>
getSettingsGtkInterfaceReducedMotion :: (MonadIO m, IsSettings o) => o -> m ReducedMotion

-- | Set the value of the “<tt>gtk-interface-reduced-motion</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkInterfaceReducedMotion <a>:=</a> value ]
--   </pre>
setSettingsGtkInterfaceReducedMotion :: (MonadIO m, IsSettings o) => o -> ReducedMotion -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-keynav-use-caret</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkKeynavUseCaret :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-keynav-use-caret</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkKeynavUseCaret
--   </pre>
getSettingsGtkKeynavUseCaret :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-keynav-use-caret</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkKeynavUseCaret <a>:=</a> value ]
--   </pre>
setSettingsGtkKeynavUseCaret :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-label-select-on-focus</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkLabelSelectOnFocus :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-label-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkLabelSelectOnFocus
--   </pre>
getSettingsGtkLabelSelectOnFocus :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-label-select-on-focus</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkLabelSelectOnFocus <a>:=</a> value ]
--   </pre>
setSettingsGtkLabelSelectOnFocus :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-long-press-time</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkLongPressTime :: (IsSettings o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-long-press-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkLongPressTime
--   </pre>
getSettingsGtkLongPressTime :: (MonadIO m, IsSettings o) => o -> m Word32

-- | Set the value of the “<tt>gtk-long-press-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkLongPressTime <a>:=</a> value ]
--   </pre>
setSettingsGtkLongPressTime :: (MonadIO m, IsSettings o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-overlay-scrolling</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkOverlayScrolling :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkOverlayScrolling
--   </pre>
getSettingsGtkOverlayScrolling :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkOverlayScrolling <a>:=</a> value ]
--   </pre>
setSettingsGtkOverlayScrolling :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-primary-button-warps-slider</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructSettingsGtkPrimaryButtonWarpsSlider :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-primary-button-warps-slider</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkPrimaryButtonWarpsSlider
--   </pre>
getSettingsGtkPrimaryButtonWarpsSlider :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-primary-button-warps-slider</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkPrimaryButtonWarpsSlider <a>:=</a> value ]
--   </pre>
setSettingsGtkPrimaryButtonWarpsSlider :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Set the value of the “<tt>gtk-print-backends</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkPrintBackends
--   </pre>
clearSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-print-backends</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkPrintBackends :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-print-backends</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkPrintBackends
--   </pre>
getSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-print-backends</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkPrintBackends <a>:=</a> value ]
--   </pre>
setSettingsGtkPrintBackends :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Set the value of the “<tt>gtk-print-preview-command</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkPrintPreviewCommand
--   </pre>
clearSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-print-preview-command</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkPrintPreviewCommand :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-print-preview-command</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkPrintPreviewCommand
--   </pre>
getSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-print-preview-command</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkPrintPreviewCommand <a>:=</a> value ]
--   </pre>
setSettingsGtkPrintPreviewCommand :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-recent-files-enabled</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkRecentFilesEnabled :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-recent-files-enabled</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkRecentFilesEnabled
--   </pre>
getSettingsGtkRecentFilesEnabled :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-recent-files-enabled</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkRecentFilesEnabled <a>:=</a> value ]
--   </pre>
setSettingsGtkRecentFilesEnabled :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-recent-files-max-age</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkRecentFilesMaxAge :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-recent-files-max-age</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkRecentFilesMaxAge
--   </pre>
getSettingsGtkRecentFilesMaxAge :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-recent-files-max-age</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkRecentFilesMaxAge <a>:=</a> value ]
--   </pre>
setSettingsGtkRecentFilesMaxAge :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-shell-shows-app-menu</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShellShowsAppMenu :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-shell-shows-app-menu</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShellShowsAppMenu
--   </pre>
getSettingsGtkShellShowsAppMenu :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-shell-shows-app-menu</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShellShowsAppMenu <a>:=</a> value ]
--   </pre>
setSettingsGtkShellShowsAppMenu :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-shell-shows-desktop</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShellShowsDesktop :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-shell-shows-desktop</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShellShowsDesktop
--   </pre>
getSettingsGtkShellShowsDesktop :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-shell-shows-desktop</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShellShowsDesktop <a>:=</a> value ]
--   </pre>
setSettingsGtkShellShowsDesktop :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-shell-shows-menubar</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShellShowsMenubar :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-shell-shows-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShellShowsMenubar
--   </pre>
getSettingsGtkShellShowsMenubar :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-shell-shows-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShellShowsMenubar <a>:=</a> value ]
--   </pre>
setSettingsGtkShellShowsMenubar :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-show-status-shapes</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkShowStatusShapes :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-show-status-shapes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkShowStatusShapes
--   </pre>
getSettingsGtkShowStatusShapes :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-show-status-shapes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkShowStatusShapes <a>:=</a> value ]
--   </pre>
setSettingsGtkShowStatusShapes :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Set the value of the “<tt>gtk-sound-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkSoundThemeName
--   </pre>
clearSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-sound-theme-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkSoundThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-sound-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkSoundThemeName
--   </pre>
getSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-sound-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkSoundThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkSoundThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-split-cursor</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkSplitCursor :: (IsSettings o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-split-cursor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkSplitCursor
--   </pre>
getSettingsGtkSplitCursor :: (MonadIO m, IsSettings o) => o -> m Bool

-- | Set the value of the “<tt>gtk-split-cursor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkSplitCursor <a>:=</a> value ]
--   </pre>
setSettingsGtkSplitCursor :: (MonadIO m, IsSettings o) => o -> Bool -> m ()

-- | Set the value of the “<tt>gtk-theme-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkThemeName
--   </pre>
clearSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-theme-name</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkThemeName :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkThemeName
--   </pre>
getSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-theme-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkThemeName <a>:=</a> value ]
--   </pre>
setSettingsGtkThemeName :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Set the value of the “<tt>gtk-titlebar-double-click</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkTitlebarDoubleClick
--   </pre>
clearSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-titlebar-double-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTitlebarDoubleClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-titlebar-double-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTitlebarDoubleClick
--   </pre>
getSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-titlebar-double-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTitlebarDoubleClick <a>:=</a> value ]
--   </pre>
setSettingsGtkTitlebarDoubleClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Set the value of the “<tt>gtk-titlebar-middle-click</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkTitlebarMiddleClick
--   </pre>
clearSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-titlebar-middle-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTitlebarMiddleClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-titlebar-middle-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTitlebarMiddleClick
--   </pre>
getSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-titlebar-middle-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTitlebarMiddleClick <a>:=</a> value ]
--   </pre>
setSettingsGtkTitlebarMiddleClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Set the value of the “<tt>gtk-titlebar-right-click</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkTitlebarRightClick
--   </pre>
clearSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-titlebar-right-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSettingsGtkTitlebarRightClick :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-titlebar-right-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkTitlebarRightClick
--   </pre>
getSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-titlebar-right-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkTitlebarRightClick <a>:=</a> value ]
--   </pre>
setSettingsGtkTitlebarRightClick :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-antialias</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkXftAntialias :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-antialias</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftAntialias
--   </pre>
getSettingsGtkXftAntialias :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-xft-antialias</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftAntialias <a>:=</a> value ]
--   </pre>
setSettingsGtkXftAntialias :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-dpi</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkXftDpi :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-dpi</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftDpi
--   </pre>
getSettingsGtkXftDpi :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-xft-dpi</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftDpi <a>:=</a> value ]
--   </pre>
setSettingsGtkXftDpi :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-hinting</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkXftHinting :: (IsSettings o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-hinting</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftHinting
--   </pre>
getSettingsGtkXftHinting :: (MonadIO m, IsSettings o) => o -> m Int32

-- | Set the value of the “<tt>gtk-xft-hinting</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftHinting <a>:=</a> value ]
--   </pre>
setSettingsGtkXftHinting :: (MonadIO m, IsSettings o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>gtk-xft-hintstyle</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkXftHintstyle
--   </pre>
clearSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-hintstyle</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSettingsGtkXftHintstyle :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-hintstyle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftHintstyle
--   </pre>
getSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-xft-hintstyle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftHintstyle <a>:=</a> value ]
--   </pre>
setSettingsGtkXftHintstyle :: (MonadIO m, IsSettings o) => o -> Text -> m ()

-- | Set the value of the “<tt>gtk-xft-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #gtkXftRgba
--   </pre>
clearSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gtk-xft-rgba</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSettingsGtkXftRgba :: (IsSettings o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>gtk-xft-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> settings #gtkXftRgba
--   </pre>
getSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>gtk-xft-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> settings [ #gtkXftRgba <a>:=</a> value ]
--   </pre>
setSettingsGtkXftRgba :: (MonadIO m, IsSettings o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Settings.Settings
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Settings.Settings
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Settings.Settings
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Settings.Settings)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Settings.Settings o) => GI.Gtk.Objects.Settings.IsSettings o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Settings.Settings
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Settings.Settings


-- | Tracks how a <tt>GtkShortcut</tt> can be activated.
--   
--   To find out if a <tt>GtkShortcutTrigger</tt> triggers, you can call
--   <a>shortcutTriggerTrigger</a> on a <tt>GdkEvent</tt>.
--   
--   <tt>GtkShortcutTriggers</tt> contain functions that allow easy
--   presentation to end users as well as being printed for debugging.
--   
--   All <tt>GtkShortcutTriggers</tt> are immutable, you can only specify
--   their properties during construction. If you want to change a trigger,
--   you have to replace it with a new one.
module GI.Gtk.Objects.ShortcutTrigger

-- | Memory-managed wrapper type.
newtype ShortcutTrigger
ShortcutTrigger :: ManagedPtr ShortcutTrigger -> ShortcutTrigger

-- | Type class for types which can be safely cast to
--   <a>ShortcutTrigger</a>, for instance with <a>toShortcutTrigger</a>.
class (GObject o, IsDescendantOf ShortcutTrigger o) => IsShortcutTrigger o

-- | Cast to <a>ShortcutTrigger</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutTrigger :: (MonadIO m, IsShortcutTrigger o) => o -> m ShortcutTrigger

-- | The types of <i><tt>trigger1</tt></i> and <i><tt>trigger2</tt></i> are
--   <tt>gconstpointer</tt> only to allow use of this function as a
--   <tt>GCompareFunc</tt>.
--   
--   They must each be a <tt>GtkShortcutTrigger</tt>.
shortcutTriggerCompare :: (HasCallStack, MonadIO m, IsShortcutTrigger a, IsShortcutTrigger b) => a -> b -> m Int32

-- | Checks if <i><tt>trigger1</tt></i> and <i><tt>trigger2</tt></i>
--   trigger under the same conditions.
--   
--   The types of <i><tt>one</tt></i> and <i><tt>two</tt></i> are
--   <tt>gconstpointer</tt> only to allow use of this function with
--   <tt>GHashTable</tt>. They must each be a <tt>GtkShortcutTrigger</tt>.
shortcutTriggerEqual :: (HasCallStack, MonadIO m, IsShortcutTrigger a, IsShortcutTrigger b) => a -> b -> m Bool

-- | Generates a hash value for a <tt>GtkShortcutTrigger</tt>.
--   
--   The output of this function is guaranteed to be the same for a given
--   value only per-process. It may change between different processor
--   architectures or even different versions of GTK. Do not use this
--   function as a basis for building protocols or file formats.
--   
--   The types of <i><tt>trigger</tt></i> is <tt>gconstpointer</tt> only to
--   allow use of this function with <tt>GHashTable</tt>. They must each be
--   a <tt>GtkShortcutTrigger</tt>.
shortcutTriggerHash :: (HasCallStack, MonadIO m, IsShortcutTrigger a) => a -> m Word32

-- | Tries to parse the given string into a trigger.
--   
--   On success, the parsed trigger is returned. When parsing failed,
--   <a>Nothing</a> is returned.
--   
--   The accepted strings are:
--   
--   <ul>
--   <li><tt>never</tt>, for <tt>GtkNeverTrigger</tt></li>
--   <li>a string parsed by <a>acceleratorParse</a>, for a
--   <tt>GtkKeyvalTrigger</tt>, e.g. <tt>&lt;Control&gt;C</tt></li>
--   <li>underscore, followed by a single character, for
--   <tt>GtkMnemonicTrigger</tt>, e.g. <tt>_l</tt></li>
--   <li>two valid trigger strings, separated by a <tt>|</tt> character,
--   for a <tt>GtkAlternativeTrigger</tt>:
--   <tt>&lt;Control&gt;q|&lt;Control&gt;w</tt></li>
--   </ul>
--   
--   Note that you will have to escape the <tt>&lt;</tt> and <tt>&gt;</tt>
--   characters when specifying triggers in XML files, such as GtkBuilder
--   ui files. Use <tt>&amp;lt;</tt> instead of <tt>&lt;</tt> and
--   <tt>&amp;gt;</tt> instead of <tt>&gt;</tt>.
shortcutTriggerParseString :: (HasCallStack, MonadIO m) => Text -> m (Maybe ShortcutTrigger)

-- | Prints the given trigger into a string for the developer. This is
--   meant for debugging and logging.
--   
--   The form of the representation may change at any time and is not
--   guaranteed to stay identical.
shortcutTriggerPrint :: (HasCallStack, MonadIO m, IsShortcutTrigger a) => a -> String -> m ()

-- | Prints the given trigger into a string.
--   
--   This function is returning a translated string for presentation to end
--   users for example in menu items or in help texts.
--   
--   The <i><tt>display</tt></i> in use may influence the resulting string
--   in various forms, such as resolving hardware keycodes or by causing
--   display-specific modifier names.
--   
--   The form of the representation may change at any time and is not
--   guaranteed to stay identical.
shortcutTriggerPrintLabel :: (HasCallStack, MonadIO m, IsShortcutTrigger a, IsDisplay b) => a -> b -> String -> m Bool

-- | Gets textual representation for the given trigger.
--   
--   This function is returning a translated string for presentation to end
--   users for example in menu items or in help texts.
--   
--   The <i><tt>display</tt></i> in use may influence the resulting string
--   in various forms, such as resolving hardware keycodes or by causing
--   display-specific modifier names.
--   
--   The form of the representation may change at any time and is not
--   guaranteed to stay identical.
shortcutTriggerToLabel :: (HasCallStack, MonadIO m, IsShortcutTrigger a, IsDisplay b) => a -> b -> m Text

-- | Prints the given trigger into a human-readable string.
--   
--   This is a small wrapper around <a>shortcutTriggerPrint</a> to help
--   when debugging.
shortcutTriggerToString :: (HasCallStack, MonadIO m, IsShortcutTrigger a) => a -> m Text

-- | Checks if the given <i><tt>event</tt></i> triggers
--   <i><tt>self</tt></i>.
shortcutTriggerTrigger :: (HasCallStack, MonadIO m, IsShortcutTrigger a, IsEvent b) => a -> b -> Bool -> m KeyMatch
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutTrigger.ShortcutTrigger
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutTrigger.ShortcutTrigger
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutTrigger.ShortcutTrigger
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutTrigger.ShortcutTrigger)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutTrigger.ShortcutTrigger o) => GI.Gtk.Objects.ShortcutTrigger.IsShortcutTrigger o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutTrigger.ShortcutTrigger
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutTrigger.ShortcutTrigger


-- | A <tt>GtkShortcutTrigger</tt> that never triggers.
module GI.Gtk.Objects.NeverTrigger

-- | Memory-managed wrapper type.
newtype NeverTrigger
NeverTrigger :: ManagedPtr NeverTrigger -> NeverTrigger

-- | Type class for types which can be safely cast to <a>NeverTrigger</a>,
--   for instance with <a>toNeverTrigger</a>.
class (GObject o, IsDescendantOf NeverTrigger o) => IsNeverTrigger o

-- | Cast to <a>NeverTrigger</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNeverTrigger :: (MonadIO m, IsNeverTrigger o) => o -> m NeverTrigger

-- | Gets the never trigger.
--   
--   This is a singleton for a trigger that never triggers. Use this
--   trigger instead of <a>Nothing</a> because it implements all virtual
--   functions.
neverTriggerGet :: (HasCallStack, MonadIO m) => m NeverTrigger
instance GHC.Classes.Eq GI.Gtk.Objects.NeverTrigger.NeverTrigger
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.NeverTrigger.NeverTrigger
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.NeverTrigger.NeverTrigger
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.NeverTrigger.NeverTrigger)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.NeverTrigger.NeverTrigger o) => GI.Gtk.Objects.NeverTrigger.IsNeverTrigger o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.NeverTrigger.NeverTrigger
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.NeverTrigger.NeverTrigger


-- | Triggers when a specific mnemonic is pressed.
--   
--   Mnemonics require a *mnemonic modifier* (typically
--   &lt;kbd&gt;Alt&lt;/kbd&gt;) to be pressed together with the mnemonic
--   key.
module GI.Gtk.Objects.MnemonicTrigger

-- | Memory-managed wrapper type.
newtype MnemonicTrigger
MnemonicTrigger :: ManagedPtr MnemonicTrigger -> MnemonicTrigger

-- | Type class for types which can be safely cast to
--   <a>MnemonicTrigger</a>, for instance with <a>toMnemonicTrigger</a>.
class (GObject o, IsDescendantOf MnemonicTrigger o) => IsMnemonicTrigger o

-- | Cast to <a>MnemonicTrigger</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toMnemonicTrigger :: (MonadIO m, IsMnemonicTrigger o) => o -> m MnemonicTrigger

-- | Gets the keyval that must be pressed to succeed triggering
--   <i><tt>self</tt></i>.
mnemonicTriggerGetKeyval :: (HasCallStack, MonadIO m, IsMnemonicTrigger a) => a -> m Word32

-- | Creates a <tt>GtkShortcutTrigger</tt> that will trigger whenever the
--   key with the given <i><tt>keyval</tt></i> is pressed and mnemonics
--   have been activated.
--   
--   Mnemonics are activated by calling code when a key event with the
--   right modifiers is detected.
mnemonicTriggerNew :: (HasCallStack, MonadIO m) => Word32 -> m MnemonicTrigger

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>keyval</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMnemonicTriggerKeyval :: (IsMnemonicTrigger o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>keyval</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mnemonicTrigger #keyval
--   </pre>
getMnemonicTriggerKeyval :: (MonadIO m, IsMnemonicTrigger o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.MnemonicTrigger.MnemonicTrigger
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MnemonicTrigger.MnemonicTrigger
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MnemonicTrigger.MnemonicTrigger
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MnemonicTrigger.MnemonicTrigger)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MnemonicTrigger.MnemonicTrigger o) => GI.Gtk.Objects.MnemonicTrigger.IsMnemonicTrigger o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MnemonicTrigger.MnemonicTrigger
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MnemonicTrigger.MnemonicTrigger


-- | Triggers when a specific keyval and modifiers are pressed.
module GI.Gtk.Objects.KeyvalTrigger

-- | Memory-managed wrapper type.
newtype KeyvalTrigger
KeyvalTrigger :: ManagedPtr KeyvalTrigger -> KeyvalTrigger

-- | Type class for types which can be safely cast to <a>KeyvalTrigger</a>,
--   for instance with <a>toKeyvalTrigger</a>.
class (GObject o, IsDescendantOf KeyvalTrigger o) => IsKeyvalTrigger o

-- | Cast to <a>KeyvalTrigger</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toKeyvalTrigger :: (MonadIO m, IsKeyvalTrigger o) => o -> m KeyvalTrigger

-- | Gets the keyval that must be pressed to succeed triggering
--   <i><tt>self</tt></i>.
keyvalTriggerGetKeyval :: (HasCallStack, MonadIO m, IsKeyvalTrigger a) => a -> m Word32

-- | Gets the modifiers that must be present to succeed triggering
--   <i><tt>self</tt></i>.
keyvalTriggerGetModifiers :: (HasCallStack, MonadIO m, IsKeyvalTrigger a) => a -> m [ModifierType]

-- | Creates a <tt>GtkShortcutTrigger</tt> that will trigger whenever the
--   key with the given <i><tt>keyval</tt></i> and
--   <i><tt>modifiers</tt></i> is pressed.
keyvalTriggerNew :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m KeyvalTrigger

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>keyval</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructKeyvalTriggerKeyval :: (IsKeyvalTrigger o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>keyval</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> keyvalTrigger #keyval
--   </pre>
getKeyvalTriggerKeyval :: (MonadIO m, IsKeyvalTrigger o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modifiers</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructKeyvalTriggerModifiers :: (IsKeyvalTrigger o, MonadIO m) => [ModifierType] -> m (GValueConstruct o)

-- | Get the value of the “<tt>modifiers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> keyvalTrigger #modifiers
--   </pre>
getKeyvalTriggerModifiers :: (MonadIO m, IsKeyvalTrigger o) => o -> m [ModifierType]
instance GHC.Classes.Eq GI.Gtk.Objects.KeyvalTrigger.KeyvalTrigger
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.KeyvalTrigger.KeyvalTrigger
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.KeyvalTrigger.KeyvalTrigger
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.KeyvalTrigger.KeyvalTrigger)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.KeyvalTrigger.KeyvalTrigger o) => GI.Gtk.Objects.KeyvalTrigger.IsKeyvalTrigger o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.KeyvalTrigger.KeyvalTrigger
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.KeyvalTrigger.KeyvalTrigger


-- | Combines two shortcut triggers.
--   
--   The <tt>GtkAlternativeTrigger</tt> triggers when either of the two
--   trigger.
--   
--   This can be cascaded to combine more than two triggers.
module GI.Gtk.Objects.AlternativeTrigger

-- | Memory-managed wrapper type.
newtype AlternativeTrigger
AlternativeTrigger :: ManagedPtr AlternativeTrigger -> AlternativeTrigger

-- | Type class for types which can be safely cast to
--   <a>AlternativeTrigger</a>, for instance with
--   <a>toAlternativeTrigger</a>.
class (GObject o, IsDescendantOf AlternativeTrigger o) => IsAlternativeTrigger o

-- | Cast to <a>AlternativeTrigger</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toAlternativeTrigger :: (MonadIO m, IsAlternativeTrigger o) => o -> m AlternativeTrigger

-- | Gets the first of the two alternative triggers that may trigger
--   <i><tt>self</tt></i>.
--   
--   <a>alternativeTriggerGetSecond</a> will return the other one.
alternativeTriggerGetFirst :: (HasCallStack, MonadIO m, IsAlternativeTrigger a) => a -> m ShortcutTrigger

-- | Gets the second of the two alternative triggers that may trigger
--   <i><tt>self</tt></i>.
--   
--   <a>alternativeTriggerGetFirst</a> will return the other one.
alternativeTriggerGetSecond :: (HasCallStack, MonadIO m, IsAlternativeTrigger a) => a -> m ShortcutTrigger

-- | Creates a <tt>GtkShortcutTrigger</tt> that will trigger whenever
--   either of the two given triggers gets triggered.
--   
--   Note that nesting is allowed, so if you want more than two
--   alternative, create a new alternative trigger for each option.
alternativeTriggerNew :: (HasCallStack, MonadIO m, IsShortcutTrigger a, IsShortcutTrigger b) => a -> b -> m AlternativeTrigger

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>first</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlternativeTriggerFirst :: (IsAlternativeTrigger o, MonadIO m, IsShortcutTrigger a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>first</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alternativeTrigger #first
--   </pre>
getAlternativeTriggerFirst :: (MonadIO m, IsAlternativeTrigger o) => o -> m ShortcutTrigger

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>second</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlternativeTriggerSecond :: (IsAlternativeTrigger o, MonadIO m, IsShortcutTrigger a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>second</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alternativeTrigger #second
--   </pre>
getAlternativeTriggerSecond :: (MonadIO m, IsAlternativeTrigger o) => o -> m ShortcutTrigger
instance GHC.Classes.Eq GI.Gtk.Objects.AlternativeTrigger.AlternativeTrigger
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AlternativeTrigger.AlternativeTrigger
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AlternativeTrigger.AlternativeTrigger
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AlternativeTrigger.AlternativeTrigger o) => GI.Gtk.Objects.AlternativeTrigger.IsAlternativeTrigger o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AlternativeTrigger.AlternativeTrigger)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AlternativeTrigger.AlternativeTrigger
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AlternativeTrigger.AlternativeTrigger


-- | Emits signals to manage listitems.
--   
--   Signals are emitted for every listitem in the same order:
--   
--   <ol>
--   <li><a>SignalListItemFactory::setup</a> is emitted to set up permanent
--   things on the listitem. This usually means constructing the widgets
--   used in the row and adding them to the listitem.</li>
--   <li><a>SignalListItemFactory::bind</a> is emitted to bind the item
--   passed via <a>ListItem:item</a> to the widgets that have been created
--   in step 1 or to add item-specific widgets. Signals are connected to
--   listen to changes - both to changes in the item to update the widgets
--   or to changes in the widgets to update the item. After this signal has
--   been called, the listitem may be shown in a list widget.</li>
--   <li><a>SignalListItemFactory::unbind</a> is emitted to undo everything
--   done in step 2. Usually this means disconnecting signal handlers. Once
--   this signal has been called, the listitem will no longer be used in a
--   list widget.</li>
--   <li><a>SignalListItemFactory::bind</a> and
--   <a>SignalListItemFactory::unbind</a> may be emitted multiple times
--   again to bind the listitem for use with new items. By reusing
--   listitems, potentially costly setup can be avoided. However, it means
--   code needs to make sure to properly clean up the listitem in step 3 so
--   that no information from the previous use leaks into the next
--   one.</li>
--   <li><a>SignalListItemFactory::teardown</a> is emitted to allow undoing
--   the effects of <a>SignalListItemFactory::setup</a>. After this signal
--   was emitted on a listitem, the listitem will be destroyed and not be
--   used again.</li>
--   </ol>
--   
--   Note that during the signal emissions, changing properties on the
--   listitems passed will not trigger notify signals as the listitem's
--   notifications are frozen. See <a>objectFreezeNotify</a> for details.
--   
--   For tracking changes in other properties in the listitem, the
--   <a>notify</a> signal is recommended. The signal can be connected in
--   the <a>SignalListItemFactory::setup</a> signal and removed again
--   during <a>SignalListItemFactory::teardown</a>.
module GI.Gtk.Objects.SignalListItemFactory

-- | Memory-managed wrapper type.
newtype SignalListItemFactory
SignalListItemFactory :: ManagedPtr SignalListItemFactory -> SignalListItemFactory

-- | Type class for types which can be safely cast to
--   <a>SignalListItemFactory</a>, for instance with
--   <a>toSignalListItemFactory</a>.
class (GObject o, IsDescendantOf SignalListItemFactory o) => IsSignalListItemFactory o

-- | Cast to <a>SignalListItemFactory</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toSignalListItemFactory :: (MonadIO m, IsSignalListItemFactory o) => o -> m SignalListItemFactory

-- | Creates a new <tt>GtkSignalListItemFactory</tt>.
--   
--   You need to connect signal handlers before you use it.
signalListItemFactoryNew :: (HasCallStack, MonadIO m) => m SignalListItemFactory

-- | Emitted when an object has been bound to an item.
--   
--   The handler for this signal must set to populate the listitem with
--   widgets.
--   
--   After this signal was emitted, the object might be shown in a
--   <a>ListView</a> or other widget.
--   
--   The <a>SignalListItemFactory::unbind</a> signal is the opposite of
--   this signal and can be used to undo everything done in this signal.
type SignalListItemFactoryBindCallback = Object -> IO ()

-- | Connect a signal handler for the <a>bind</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> signalListItemFactory #bind callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSignalListItemFactoryBind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryBindCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>bind</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> signalListItemFactory #bind callback
--   </pre>
onSignalListItemFactoryBind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryBindCallback) -> m SignalHandlerId

-- | Emitted when a newly created listitem needs to be prepared for use.
--   
--   It is the first signal emitted for every listitem.
--   
--   The handler for this signal must call <a>listItemSetChild</a> to
--   populate the listitem with widgets.
--   
--   The <a>SignalListItemFactory::teardown</a> signal is the opposite of
--   this signal and can be used to undo everything done in this signal.
type SignalListItemFactorySetupCallback = Object -> IO ()

-- | Connect a signal handler for the <a>setup</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> signalListItemFactory #setup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSignalListItemFactorySetup :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactorySetupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setup</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> signalListItemFactory #setup callback
--   </pre>
onSignalListItemFactorySetup :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactorySetupCallback) -> m SignalHandlerId

-- | Emitted when an object is about to be destroyed.
--   
--   It is the last signal ever emitted for this <i><tt>object</tt></i>.
--   
--   This signal is the opposite of the <a>SignalListItemFactory::setup</a>
--   signal and should be used to undo everything done in that signal.
type SignalListItemFactoryTeardownCallback = Object -> IO ()

-- | Connect a signal handler for the <a>teardown</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> signalListItemFactory #teardown callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSignalListItemFactoryTeardown :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryTeardownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>teardown</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> signalListItemFactory #teardown callback
--   </pre>
onSignalListItemFactoryTeardown :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryTeardownCallback) -> m SignalHandlerId

-- | Emitted when an object has been unbound from its item.
--   
--   This happens for example when a listitem was removed from use in a
--   list widget and its <a>ListItem:item</a> is about to be unset.
--   
--   This signal is the opposite of the <a>SignalListItemFactory::bind</a>
--   signal and should be used to undo everything done in that signal.
type SignalListItemFactoryUnbindCallback = Object -> IO ()

-- | Connect a signal handler for the <a>unbind</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> signalListItemFactory #unbind callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSignalListItemFactoryUnbind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryUnbindCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unbind</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> signalListItemFactory #unbind callback
--   </pre>
onSignalListItemFactoryUnbind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryUnbindCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.SignalListItemFactory.SignalListItemFactory
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SignalListItemFactory.SignalListItemFactory
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SignalListItemFactory.SignalListItemFactory
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SignalListItemFactory.SignalListItemFactory)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SignalListItemFactory.SignalListItemFactory o) => GI.Gtk.Objects.SignalListItemFactory.IsSignalListItemFactory o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SignalListItemFactory.SignalListItemFactory
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SignalListItemFactory.SignalListItemFactory


-- | A list model that presents a slice of another model.
--   
--   This is useful when implementing paging by setting the size to the
--   number of elements per page and updating the offset whenever a
--   different page is opened.
--   
--   <tt>GtkSliceListModel</tt> passes through sections from the underlying
--   model.
module GI.Gtk.Objects.SliceListModel

-- | Memory-managed wrapper type.
newtype SliceListModel
SliceListModel :: ManagedPtr SliceListModel -> SliceListModel

-- | Type class for types which can be safely cast to
--   <a>SliceListModel</a>, for instance with <a>toSliceListModel</a>.
class (GObject o, IsDescendantOf SliceListModel o) => IsSliceListModel o

-- | Cast to <a>SliceListModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSliceListModel :: (MonadIO m, IsSliceListModel o) => o -> m SliceListModel

-- | Gets the model that is currently being used or <a>Nothing</a> if none.
sliceListModelGetModel :: (HasCallStack, MonadIO m, IsSliceListModel a) => a -> m (Maybe ListModel)

-- | Gets the offset set via <a>sliceListModelSetOffset</a>.
sliceListModelGetOffset :: (HasCallStack, MonadIO m, IsSliceListModel a) => a -> m Word32

-- | Gets the size set via <a>sliceListModelSetSize</a>.
sliceListModelGetSize :: (HasCallStack, MonadIO m, IsSliceListModel a) => a -> m Word32

-- | Creates a new slice model.
--   
--   It presents the slice from <i><tt>offset</tt></i> to offset +
--   <i><tt>size</tt></i> of the given <i><tt>model</tt></i>.
sliceListModelNew :: (HasCallStack, MonadIO m, IsListModel a) => Maybe a -> Word32 -> Word32 -> m SliceListModel

-- | Sets the model to show a slice of.
--   
--   The model's item type must conform to <i><tt>self</tt></i>'s item
--   type.
sliceListModelSetModel :: (HasCallStack, MonadIO m, IsSliceListModel a, IsListModel b) => a -> Maybe b -> m ()

-- | Sets the offset into the original model for this slice.
--   
--   If the offset is too large for the sliced model, <i><tt>self</tt></i>
--   will end up empty.
sliceListModelSetOffset :: (HasCallStack, MonadIO m, IsSliceListModel a) => a -> Word32 -> m ()

-- | Sets the maximum size. <i><tt>self</tt></i> will never have more items
--   than <i><tt>size</tt></i>.
--   
--   It can however have fewer items if the offset is too large or the
--   model sliced from doesn't have enough items.
sliceListModelSetSize :: (HasCallStack, MonadIO m, IsSliceListModel a) => a -> Word32 -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sliceListModel #itemType
--   </pre>
getSliceListModelItemType :: (MonadIO m, IsSliceListModel o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearSliceListModelModel :: (MonadIO m, IsSliceListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSliceListModelModel :: (IsSliceListModel o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sliceListModel #model
--   </pre>
getSliceListModelModel :: (MonadIO m, IsSliceListModel o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sliceListModel [ #model <a>:=</a> value ]
--   </pre>
setSliceListModelModel :: (MonadIO m, IsSliceListModel o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sliceListModel #nItems
--   </pre>
getSliceListModelNItems :: (MonadIO m, IsSliceListModel o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>offset</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSliceListModelOffset :: (IsSliceListModel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>offset</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sliceListModel #offset
--   </pre>
getSliceListModelOffset :: (MonadIO m, IsSliceListModel o) => o -> m Word32

-- | Set the value of the “<tt>offset</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sliceListModel [ #offset <a>:=</a> value ]
--   </pre>
setSliceListModelOffset :: (MonadIO m, IsSliceListModel o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSliceListModelSize :: (IsSliceListModel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sliceListModel #size
--   </pre>
getSliceListModelSize :: (MonadIO m, IsSliceListModel o) => o -> m Word32

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sliceListModel [ #size <a>:=</a> value ]
--   </pre>
setSliceListModelSize :: (MonadIO m, IsSliceListModel o) => o -> Word32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.SliceListModel.SliceListModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SliceListModel.SliceListModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SliceListModel.SliceListModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SliceListModel.SliceListModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SliceListModel.SliceListModel o) => GI.Gtk.Objects.SliceListModel.IsSliceListModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SliceListModel.SliceListModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SliceListModel.SliceListModel


-- | Describes sorting criteria for a <a>SortListModel</a>.
--   
--   Its primary user is <a>SortListModel</a>
--   
--   The model will use a sorter to determine the order in which its items
--   should appear by calling <a>sorterCompare</a> for pairs of items.
--   
--   Sorters may change their sorting behavior through their lifetime. In
--   that case, they will emit the <a>Sorter::changed</a> signal to notify
--   that the sort order is no longer valid and should be updated by
--   calling <a>sorterCompare</a> again.
--   
--   GTK provides various pre-made sorter implementations for common
--   sorting operations. <a>ColumnView</a> has built-in support for sorting
--   lists via the <a>ColumnViewColumn:sorter</a> property, where the user
--   can change the sorting by clicking on list headers.
--   
--   Of course, in particular for large lists, it is also possible to
--   subclass <tt>GtkSorter</tt> and provide one's own sorter.
module GI.Gtk.Objects.Sorter

-- | Memory-managed wrapper type.
newtype Sorter
Sorter :: ManagedPtr Sorter -> Sorter

-- | Type class for types which can be safely cast to <a>Sorter</a>, for
--   instance with <a>toSorter</a>.
class (GObject o, IsDescendantOf Sorter o) => IsSorter o

-- | Cast to <a>Sorter</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSorter :: (MonadIO m, IsSorter o) => o -> m Sorter

-- | Notifies all users of the sorter that it has changed.
--   
--   This emits the <a>Sorter::changed</a> signal. Users of the sorter
--   should then update the sort order via <a>sorterCompare</a>.
--   
--   Depending on the <i><tt>change</tt></i> parameter, it may be possible
--   to update the sort order without a full resorting. Refer to the
--   <a>SorterChange</a> documentation for details.
--   
--   This function is intended for implementers of <tt>GtkSorter</tt>
--   subclasses and should not be called from other functions.
sorterChanged :: (HasCallStack, MonadIO m, IsSorter a) => a -> SorterChange -> m ()

-- | Compares two given items according to the sort order implemented by
--   the sorter.
--   
--   Sorters implement a partial order:
--   
--   <ul>
--   <li>It is reflexive, ie a = a</li>
--   <li>It is antisymmetric, ie if a &lt; b and b &lt; a, then a = b</li>
--   <li>It is transitive, ie given any 3 items with a ≤ b and b ≤ c, then
--   a ≤ c</li>
--   </ul>
--   
--   The sorter may signal it conforms to additional constraints via the
--   return value of <a>sorterGetOrder</a>.
sorterCompare :: (HasCallStack, MonadIO m, IsSorter a, IsObject b, IsObject c) => a -> b -> c -> m Ordering

-- | Gets the order that <i><tt>self</tt></i> conforms to.
--   
--   See <a>SorterOrder</a> for details of the possible return values.
--   
--   This function is intended to allow optimizations.
sorterGetOrder :: (HasCallStack, MonadIO m, IsSorter a) => a -> m SorterOrder

-- | Emitted whenever the sorter changed.
--   
--   Users of the sorter should then update the sort order again via
--   <a>sorterCompare</a>.
--   
--   <a>SortListModel</a> handles this signal automatically.
--   
--   Depending on the <i><tt>change</tt></i> parameter, it may be possible
--   to update the sort order without a full resorting. Refer to the
--   <a>SorterChange</a> documentation for details.
type SorterChangedCallback = SorterChange -> IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> sorter #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSorterChanged :: (IsSorter a, MonadIO m) => a -> ((?self :: a) => SorterChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> sorter #changed callback
--   </pre>
onSorterChanged :: (IsSorter a, MonadIO m) => a -> ((?self :: a) => SorterChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Sorter.Sorter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Sorter.Sorter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Sorter.Sorter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Sorter.Sorter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Sorter.Sorter o) => GI.Gtk.Objects.Sorter.IsSorter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Sorter.Sorter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Sorter.Sorter


-- | A list model that sorts the elements of another model.
--   
--   The elements are sorted according to a <tt>GtkSorter</tt>.
--   
--   The model is a stable sort. If two items compare equal according to
--   the sorter, the one that appears first in the original model will also
--   appear first after sorting.
--   
--   Note that if you change the sorter, the previous order will have no
--   influence on the new order. If you want that, consider using a
--   <tt>GtkMultiSorter</tt> and appending the previous sorter to it.
--   
--   The model can be set up to do incremental sorting, so that sorting
--   long lists doesn't block the UI. See
--   <a>sortListModelSetIncremental</a> for details.
--   
--   <tt>GtkSortListModel</tt> is a generic model and because of that it
--   cannot take advantage of any external knowledge when sorting. If you
--   run into performance issues with <tt>GtkSortListModel</tt>, it is
--   strongly recommended that you write your own sorting list model.
--   
--   <tt>GtkSortListModel</tt> allows sorting the items into sections. It
--   implements <tt>GtkSectionModel</tt> and when
--   <a>SortListModel:sectionSorter</a> is set, it will sort all items with
--   that sorter and items comparing equal with it will be put into the
--   same section. The <a>SortListModel:sorter</a> will then be used to
--   sort items inside their sections.
module GI.Gtk.Objects.SortListModel

-- | Memory-managed wrapper type.
newtype SortListModel
SortListModel :: ManagedPtr SortListModel -> SortListModel

-- | Type class for types which can be safely cast to <a>SortListModel</a>,
--   for instance with <a>toSortListModel</a>.
class (GObject o, IsDescendantOf SortListModel o) => IsSortListModel o

-- | Cast to <a>SortListModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSortListModel :: (MonadIO m, IsSortListModel o) => o -> m SortListModel

-- | Returns whether incremental sorting is enabled.
--   
--   See <a>sortListModelSetIncremental</a>.
sortListModelGetIncremental :: (HasCallStack, MonadIO m, IsSortListModel a) => a -> m Bool

-- | Gets the model currently sorted or <a>Nothing</a> if none.
sortListModelGetModel :: (HasCallStack, MonadIO m, IsSortListModel a) => a -> m (Maybe ListModel)

-- | Estimates progress of an ongoing sorting operation.
--   
--   The estimate is the number of items that would still need to be sorted
--   to finish the sorting operation if this was a linear algorithm. So
--   this number is not related to how many items are already correctly
--   sorted.
--   
--   If you want to estimate the progress, you can use code like this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   pending = gtk_sort_list_model_get_pending (self);
--   model = gtk_sort_list_model_get_model (self);
--   progress = 1.0 - pending / (double) MAX (1, g_list_model_get_n_items (model));
--   </pre>
--   
--   If no sort operation is ongoing - in particular when
--   <a>SortListModel:incremental</a> is <a>False</a> - this function
--   returns 0.
sortListModelGetPending :: (HasCallStack, MonadIO m, IsSortListModel a) => a -> m Word32

-- | Gets the section sorter that is used to sort items of
--   <i><tt>self</tt></i> into sections.
--   
--   <i>Since: 4.12</i>
sortListModelGetSectionSorter :: (HasCallStack, MonadIO m, IsSortListModel a) => a -> m (Maybe Sorter)

-- | Gets the sorter that is used to sort <i><tt>self</tt></i>.
sortListModelGetSorter :: (HasCallStack, MonadIO m, IsSortListModel a) => a -> m (Maybe Sorter)

-- | Creates a new sort list model that uses the <i><tt>sorter</tt></i> to
--   sort <i><tt>model</tt></i>.
sortListModelNew :: (HasCallStack, MonadIO m, IsListModel a, IsSorter b) => Maybe a -> Maybe b -> m SortListModel

-- | Sets the sort model to do an incremental sort.
--   
--   When incremental sorting is enabled, the <tt>GtkSortListModel</tt>
--   will not do a complete sort immediately, but will instead queue an
--   idle handler that incrementally sorts the items towards their correct
--   position. This of course means that items do not instantly appear in
--   the right place. It also means that the total sorting time is a lot
--   slower.
--   
--   When your filter blocks the UI while sorting, you might consider
--   turning this on. Depending on your model and sorters, this may become
--   interesting around 10,000 to 100,000 items.
--   
--   By default, incremental sorting is disabled.
--   
--   See <a>sortListModelGetPending</a> for progress information about an
--   ongoing incremental sorting operation.
sortListModelSetIncremental :: (HasCallStack, MonadIO m, IsSortListModel a) => a -> Bool -> m ()

-- | Sets the model to be sorted.
--   
--   The <i><tt>model</tt></i>'s item type must conform to the item type of
--   <i><tt>self</tt></i>.
sortListModelSetModel :: (HasCallStack, MonadIO m, IsSortListModel a, IsListModel b) => a -> Maybe b -> m ()

-- | Sets a new section sorter on <i><tt>self</tt></i>.
--   
--   <i>Since: 4.12</i>
sortListModelSetSectionSorter :: (HasCallStack, MonadIO m, IsSortListModel a, IsSorter b) => a -> Maybe b -> m ()

-- | Sets a new sorter on <i><tt>self</tt></i>.
sortListModelSetSorter :: (HasCallStack, MonadIO m, IsSortListModel a, IsSorter b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>incremental</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSortListModelIncremental :: (IsSortListModel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>incremental</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sortListModel #incremental
--   </pre>
getSortListModelIncremental :: (MonadIO m, IsSortListModel o) => o -> m Bool

-- | Set the value of the “<tt>incremental</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sortListModel [ #incremental <a>:=</a> value ]
--   </pre>
setSortListModelIncremental :: (MonadIO m, IsSortListModel o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sortListModel #itemType
--   </pre>
getSortListModelItemType :: (MonadIO m, IsSortListModel o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearSortListModelModel :: (MonadIO m, IsSortListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSortListModelModel :: (IsSortListModel o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sortListModel #model
--   </pre>
getSortListModelModel :: (MonadIO m, IsSortListModel o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sortListModel [ #model <a>:=</a> value ]
--   </pre>
setSortListModelModel :: (MonadIO m, IsSortListModel o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sortListModel #nItems
--   </pre>
getSortListModelNItems :: (MonadIO m, IsSortListModel o) => o -> m Word32

-- | Get the value of the “<tt>pending</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sortListModel #pending
--   </pre>
getSortListModelPending :: (MonadIO m, IsSortListModel o) => o -> m Word32

-- | Set the value of the “<tt>section-sorter</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #sectionSorter
--   </pre>
clearSortListModelSectionSorter :: (MonadIO m, IsSortListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>section-sorter</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSortListModelSectionSorter :: (IsSortListModel o, MonadIO m, IsSorter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>section-sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sortListModel #sectionSorter
--   </pre>
getSortListModelSectionSorter :: (MonadIO m, IsSortListModel o) => o -> m (Maybe Sorter)

-- | Set the value of the “<tt>section-sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sortListModel [ #sectionSorter <a>:=</a> value ]
--   </pre>
setSortListModelSectionSorter :: (MonadIO m, IsSortListModel o, IsSorter a) => o -> a -> m ()

-- | Set the value of the “<tt>sorter</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #sorter
--   </pre>
clearSortListModelSorter :: (MonadIO m, IsSortListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sorter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSortListModelSorter :: (IsSortListModel o, MonadIO m, IsSorter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sortListModel #sorter
--   </pre>
getSortListModelSorter :: (MonadIO m, IsSortListModel o) => o -> m (Maybe Sorter)

-- | Set the value of the “<tt>sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sortListModel [ #sorter <a>:=</a> value ]
--   </pre>
setSortListModelSorter :: (MonadIO m, IsSortListModel o, IsSorter a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.SortListModel.SortListModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SortListModel.SortListModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SortListModel.SortListModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SortListModel.SortListModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SortListModel.SortListModel o) => GI.Gtk.Objects.SortListModel.IsSortListModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SortListModel.SortListModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SortListModel.SortListModel


-- | Combines multiple sorters by trying them in turn.
--   
--   If the first sorter compares two items as equal, the second is tried
--   next, and so on.
module GI.Gtk.Objects.MultiSorter

-- | Memory-managed wrapper type.
newtype MultiSorter
MultiSorter :: ManagedPtr MultiSorter -> MultiSorter

-- | Type class for types which can be safely cast to <a>MultiSorter</a>,
--   for instance with <a>toMultiSorter</a>.
class (GObject o, IsDescendantOf MultiSorter o) => IsMultiSorter o

-- | Cast to <a>MultiSorter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMultiSorter :: (MonadIO m, IsMultiSorter o) => o -> m MultiSorter

-- | Add <i><tt>sorter</tt></i> to <i><tt>self</tt></i> to use for sorting
--   at the end.
--   
--   <i><tt>self</tt></i> will consult all existing sorters before it will
--   sort with the given <i><tt>sorter</tt></i>.
multiSorterAppend :: (HasCallStack, MonadIO m, IsMultiSorter a, IsSorter b) => a -> b -> m ()

-- | Creates a new multi sorter.
--   
--   This sorter compares items by trying each of the sorters in turn,
--   until one returns non-zero. In particular, if no sorter has been added
--   to it, it will always compare items as equal.
multiSorterNew :: (HasCallStack, MonadIO m) => m MultiSorter

-- | Removes the sorter at the given <i><tt>position</tt></i> from the list
--   of sorter used by <i><tt>self</tt></i>.
--   
--   If <i><tt>position</tt></i> is larger than the number of sorters,
--   nothing happens.
multiSorterRemove :: (HasCallStack, MonadIO m, IsMultiSorter a) => a -> Word32 -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> multiSorter #itemType
--   </pre>
getMultiSorterItemType :: (MonadIO m, IsMultiSorter o) => o -> m GType

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> multiSorter #nItems
--   </pre>
getMultiSorterNItems :: (MonadIO m, IsMultiSorter o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.MultiSorter.MultiSorter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MultiSorter.MultiSorter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MultiSorter.MultiSorter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MultiSorter.MultiSorter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MultiSorter.MultiSorter o) => GI.Gtk.Objects.MultiSorter.IsMultiSorter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MultiSorter.MultiSorter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MultiSorter.MultiSorter


-- | Sorts items via a callback function.
module GI.Gtk.Objects.CustomSorter

-- | Memory-managed wrapper type.
newtype CustomSorter
CustomSorter :: ManagedPtr CustomSorter -> CustomSorter

-- | Type class for types which can be safely cast to <a>CustomSorter</a>,
--   for instance with <a>toCustomSorter</a>.
class (GObject o, IsDescendantOf CustomSorter o) => IsCustomSorter o

-- | Cast to <a>CustomSorter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCustomSorter :: (MonadIO m, IsCustomSorter o) => o -> m CustomSorter

-- | Creates a new <tt>GtkSorter</tt> that works by calling
--   <i><tt>sortFunc</tt></i> to compare items.
--   
--   If <i><tt>sortFunc</tt></i> is <a>Nothing</a>, all items are
--   considered equal.
customSorterNew :: (HasCallStack, MonadIO m) => Maybe CompareDataFunc -> m CustomSorter

-- | Sets (or unsets) the function used for sorting items.
--   
--   If <i><tt>sortFunc</tt></i> is <a>Nothing</a>, all items are
--   considered equal.
--   
--   If the sort func changes its sorting behavior, <a>sorterChanged</a>
--   needs to be called.
--   
--   If a previous function was set, its <i><tt>userDestroy</tt></i> will
--   be called now.
customSorterSetSortFunc :: (HasCallStack, MonadIO m, IsCustomSorter a) => a -> Maybe CompareDataFunc -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CustomSorter.CustomSorter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CustomSorter.CustomSorter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CustomSorter.CustomSorter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CustomSorter.CustomSorter o) => GI.Gtk.Objects.CustomSorter.IsCustomSorter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CustomSorter.CustomSorter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CustomSorter.CustomSorter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CustomSorter.CustomSorter


-- | A list model that wraps an array of strings.
--   
--   The objects in the model are of type <a>StringObject</a> and have a
--   "string" property that can be used inside expressions.
--   
--   <tt>GtkStringList</tt> is well-suited for any place where you would
--   typically use a <tt>char*[]</tt>, but need a list model.
--   
--   <h2>GtkStringList as GtkBuildable</h2>
--   
--   The <tt>GtkStringList</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports adding items directly using the
--   <tt>&lt;items&gt;</tt> element and specifying <tt>&lt;item&gt;</tt>
--   elements for each item. Each <tt>&lt;item&gt;</tt> element supports
--   the regular translation attributes “translatable”, “context” and
--   “comments”.
--   
--   Here is a UI definition fragment specifying a <tt>GtkStringList</tt>
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkStringList"&gt;
--     &lt;items&gt;
--       &lt;item translatable="yes"&gt;Factory&lt;/item&gt;
--       &lt;item translatable="yes"&gt;Home&lt;/item&gt;
--       &lt;item translatable="yes"&gt;Subway&lt;/item&gt;
--     &lt;/items&gt;
--   &lt;/object&gt;
--   </pre>
module GI.Gtk.Objects.StringList

-- | Memory-managed wrapper type.
newtype StringList
StringList :: ManagedPtr StringList -> StringList

-- | Type class for types which can be safely cast to <a>StringList</a>,
--   for instance with <a>toStringList</a>.
class (GObject o, IsDescendantOf StringList o) => IsStringList o

-- | Cast to <a>StringList</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStringList :: (MonadIO m, IsStringList o) => o -> m StringList

-- | Appends <i><tt>string</tt></i> to <i><tt>self</tt></i>.
--   
--   The <i><tt>string</tt></i> will be copied. See <a>stringListTake</a>
--   for a way to avoid that.
stringListAppend :: (HasCallStack, MonadIO m, IsStringList a) => a -> Text -> m ()

-- | Gets the position of the <i><tt>string</tt></i> in
--   <i><tt>self</tt></i>.
--   
--   If <i><tt>self</tt></i> does not contain <i><tt>string</tt></i> item,
--   <tt>G_MAXUINT</tt> is returned.
--   
--   <i>Since: 4.18</i>
stringListFind :: (HasCallStack, MonadIO m, IsStringList a) => a -> Text -> m Word32

-- | Gets the string that is at <i><tt>position</tt></i> in
--   <i><tt>self</tt></i>.
--   
--   If <i><tt>self</tt></i> does not contain <i><tt>position</tt></i>
--   items, <a>Nothing</a> is returned.
--   
--   This function returns the const char *. To get the object wrapping it,
--   use <tt><i>g_list_model_get_item()</i></tt>.
stringListGetString :: (HasCallStack, MonadIO m, IsStringList a) => a -> Word32 -> m (Maybe Text)

-- | Creates a new <tt>GtkStringList</tt> with the given
--   <i><tt>strings</tt></i>.
stringListNew :: (HasCallStack, MonadIO m) => Maybe [Text] -> m StringList

-- | Removes the string at <i><tt>position</tt></i> from
--   <i><tt>self</tt></i>.
--   
--   <i><tt>position</tt></i> must be smaller than the current length of
--   the list.
stringListRemove :: (HasCallStack, MonadIO m, IsStringList a) => a -> Word32 -> m ()

-- | Changes <i><tt>self</tt></i> by removing <i><tt>nRemovals</tt></i>
--   strings and adding <i><tt>additions</tt></i> to it.
--   
--   This function is more efficient than <a>stringListAppend</a> and
--   <a>stringListRemove</a>, because it only emits the <a>itemsChanged</a>
--   signal once for the change.
--   
--   This function copies the strings in <i><tt>additions</tt></i>.
--   
--   The parameters <i><tt>position</tt></i> and <i><tt>nRemovals</tt></i>
--   must be correct (ie: <i><tt>position</tt></i> +
--   <i><tt>nRemovals</tt></i> must be less than or equal to the length of
--   the list at the time this function is called).
stringListSplice :: (HasCallStack, MonadIO m, IsStringList a) => a -> Word32 -> Word32 -> Maybe [Text] -> m ()

-- | Adds <i><tt>string</tt></i> to self at the end, and takes ownership of
--   it.
--   
--   This variant of <a>stringListAppend</a> is convenient for formatting
--   strings:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   gtk_string_list_take (self, g_strdup_print ("%d dollars", lots));
--   </pre>
stringListTake :: (HasCallStack, MonadIO m, IsStringList a) => a -> Text -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringList #itemType
--   </pre>
getStringListItemType :: (MonadIO m, IsStringList o) => o -> m GType

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringList #nItems
--   </pre>
getStringListNItems :: (MonadIO m, IsStringList o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strings</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStringListStrings :: (IsStringList o, MonadIO m) => [Text] -> m (GValueConstruct o)
instance GHC.Classes.Eq GI.Gtk.Objects.StringList.StringList
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StringList.StringList
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StringList.StringList
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StringList.StringList)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StringList.StringList o) => GI.Gtk.Objects.StringList.IsStringList o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StringList.StringList
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StringList.StringList


-- | The type of items in a <tt>GtkStringList</tt>.
--   
--   A <tt>GtkStringObject</tt> is a wrapper around a <tt>const char*</tt>;
--   it has a <a>StringObject:string</a> property that can be used for
--   property bindings and expressions.
module GI.Gtk.Objects.StringObject

-- | Memory-managed wrapper type.
newtype StringObject
StringObject :: ManagedPtr StringObject -> StringObject

-- | Type class for types which can be safely cast to <a>StringObject</a>,
--   for instance with <a>toStringObject</a>.
class (GObject o, IsDescendantOf StringObject o) => IsStringObject o

-- | Cast to <a>StringObject</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStringObject :: (MonadIO m, IsStringObject o) => o -> m StringObject

-- | Returns the string contained in a <tt>GtkStringObject</tt>.
stringObjectGetString :: (HasCallStack, MonadIO m, IsStringObject a) => a -> m Text

-- | Wraps a string in an object for use with <tt>GListModel</tt>.
stringObjectNew :: (HasCallStack, MonadIO m) => Text -> m StringObject

-- | Get the value of the “<tt>string</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringObject #string
--   </pre>
getStringObjectString :: (MonadIO m, IsStringObject o) => o -> m Text
instance GHC.Classes.Eq GI.Gtk.Objects.StringObject.StringObject
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StringObject.StringObject
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StringObject.StringObject
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StringObject.StringObject)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StringObject.StringObject o) => GI.Gtk.Objects.StringObject.IsStringObject o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StringObject.StringObject
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StringObject.StringObject


-- | A paintable implementation that renders SVG, with animations.
--   
--   <tt>GtkSvg</tt> objects are created by parsing a subset of SVG,
--   including SVG animations.
--   
--   <tt>GtkSvg</tt> fills or strokes paths with symbolic or fixed colors.
--   It can have multiple states, and paths can be included in a subset of
--   the states. The special 'empty' state is always available. States can
--   have animations, and the transition between different states can also
--   be animated.
--   
--   To show a static SVG image, it is enough to load the the SVG and use
--   it like any other paintable.
--   
--   To play an SVG animation, use <a>svgSetFrameClock</a> to connect the
--   paintable to a frame clock, and call <a>svgPlay</a> after loading the
--   SVG. The animation can be paused using <a>svgPause</a>.
--   
--   To find out what states a <tt>GtkSvg</tt> has, use
--   <a>svgGetNStates</a>. To set the current state, use
--   <a>svgSetState</a>.
--   
--   <h2>Error handling</h2>
--   
--   Loading an SVG into <tt>GtkSvg</tt> will always produce a (possibly
--   empty) paintable. GTK will drop things that it can't handle and try to
--   make sense of the rest.
--   
--   To track errors during parsing or rendering, connect to the
--   <a>Svg::error</a> signal.
--   
--   For parsing errors in the <tt>GTK_SVG_ERROR</tt> domain, the functions
--   <a>SvgError</a>.<tt><i>get_start</i></tt>(),
--   <a>SvgError</a>.<tt><i>get_end</i></tt>(),
--   <a>SvgError</a>.<tt><i>get_element</i></tt>() and
--   <a>SvgError</a>.<tt><i>get_attribute</i></tt>() can be used to obtain
--   information about where the error occurred.
--   
--   <h2>The supported subset of SVG</h2>
--   
--   The paintable supports much of SVG 2, with some exceptions.
--   
--   Among the graphical elements, <tt>&lt;textPath&gt;</tt> and
--   <tt>&lt;foreignObject&gt;</tt> are not supported.
--   
--   Among the structural elements, <tt>&lt;a&gt;</tt> and
--   <tt>&lt;view&gt;</tt> are not supported.
--   
--   In the <tt>&lt;filter&gt;</tt> element, the following primitives are
--   not supported: feConvolveMatrix, feDiffuseLighting, feMorphology,
--   feSpecularLighting and feTurbulence.
--   
--   Support for the <tt>mask</tt> attribute is limited to just a url
--   referring to the <tt>&lt;mask&gt;</tt> element by ID.
--   
--   In animation elements, the parsing of <tt>begin</tt> and <tt>end</tt>
--   attributes is limited, and the <tt>min</tt> and <tt>max</tt>
--   attributes are not supported.
--   
--   Lastly, there is only minimal CSS support (the style attribute, but
--   not <tt>&lt;style&gt;</tt>), and no interactivity.
--   
--   <h2>SVG Extensions</h2>
--   
--   The paintable supports a number of <a>custom attributes</a> that offer
--   a convenient way to define states, transitions and animations. For
--   example,
--   
--   &lt;circle cx='5' cy='5' r='5' gpa:states='0 1'
--   gpa:animation-type='automatic' gpa:animation-direction='segment'
--   gpa:animation-duration='600ms'/&gt;
--   
--   defines the circle to be shown in states 0 and 1, and animates a
--   segment of the circle.
--   
--   &lt;image src="svg-renderer1.svg"&gt;
--   
--   Note that the generated animations are implemented using standard SVG
--   attributes (<tt>visibility</tt>, <tt>stroke-dasharray,
--   </tt>stroke-dashoffset<tt>, </tt>pathLength<tt> and </tt>filter@).
--   Setting these attributes in your SVG is therefore going to interfere
--   with generated animations.
--   
--   To connect general SVG animations to the states of the paintable, use
--   the custom <tt>gpa:states(...)</tt> condition in the <tt>begin</tt>
--   and <tt>end</tt> attributes of SVG animation elements. For example,
--   
--   &lt;animate href='path1' attributeName='fill'
--   begin='gpa:states(0).begin' dur='300ms' fill='freeze' from='black'
--   to='magenta'/&gt;
--   
--   will make the fill color of path1 transition from black to magenta
--   when the renderer enters state 0.
--   
--   &lt;image src="svg-renderer2.svg"&gt;
--   
--   The <tt>gpa:states(...)</tt> condition triggers for upcoming state
--   changes as well, to support fade-out transitions. For example,
--   
--   &lt;animate href='path1' attributeName='opacity'
--   begin='gpa:states(0).end -300ms' dur='300ms' fill='freeze' from='1'
--   to='0'/&gt;
--   
--   will start a fade-out of path1 300ms before state 0 ends.
--   
--   In addition to the <tt>gpa:fill</tt> and <tt>gpa:stroke</tt>
--   attributes, symbolic colors can also be specified as a custom paint
--   server reference, like this:
--   <tt>url(gpa:</tt><i>warning</i><tt>)</tt>. This works in <tt>fill</tt>
--   and <tt>stroke</tt> attributes, but also when specifying colors in SVG
--   animation attributes like <tt>to</tt> or <tt>values</tt>.
--   
--   Note that the SVG syntax allows for a fallback RGB color to be
--   specified after the url, for compatibility with other SVG consumers:
--   
--   fill='url(gpa:#warning) orange'
--   
--   In contrast to SVG 1.1 and 2.0, we allow the <tt>transform</tt>
--   attribute to be animated with @&lt;animate&gt;`.
--   
--   <i>Since: 4.22</i>
module GI.Gtk.Objects.Svg

-- | Memory-managed wrapper type.
newtype Svg
Svg :: ManagedPtr Svg -> Svg

-- | Type class for types which can be safely cast to <a>Svg</a>, for
--   instance with <a>toSvg</a>.
class (GObject o, IsDescendantOf Svg o) => IsSvg o

-- | Cast to <a>Svg</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toSvg :: (MonadIO m, IsSvg o) => o -> m Svg

-- | Returns the currently enabled features.
--   
--   <i>Since: 4.22</i>
svgGetFeatures :: (HasCallStack, MonadIO m, IsSvg a) => a -> m [SvgFeatures]

-- | Gets the number of states defined in the SVG.
--   
--   Note that there is always an empty state, which does not count towards
--   this number. If this function returns the value N, the meaningful
--   states of the SVG are 0, 1, ..., N - 1 and
--   <tt>GTK_SVG_STATE_EMPTY</tt>.
--   
--   <i>Since: 4.22</i>
svgGetNStates :: (HasCallStack, MonadIO m, IsSvg a) => a -> m Word32

-- | Gets the current state of the paintable.
--   
--   <i>Since: 4.22</i>
svgGetState :: (HasCallStack, MonadIO m, IsSvg a) => a -> m Word32

-- | Gets the value of the weight property.
--   
--   <i>Since: 4.22</i>
svgGetWeight :: (HasCallStack, MonadIO m, IsSvg a) => a -> m Double

-- | Loads SVG content into an existing SVG paintable.
--   
--   To track errors while loading SVG content, connect to the
--   <a>Svg::error</a> signal.
--   
--   This clears any previously loaded content.
--   
--   <i>Since: 4.22</i>
svgLoadFromBytes :: (HasCallStack, MonadIO m, IsSvg a) => a -> Bytes -> m ()

-- | Loads SVG content into an existing SVG paintable.
--   
--   To track errors while loading SVG content, connect to the
--   <a>Svg::error</a> signal.
--   
--   This clears any previously loaded content.
--   
--   <i>Since: 4.22</i>
svgLoadFromResource :: (HasCallStack, MonadIO m, IsSvg a) => a -> Text -> m ()

-- | Creates a new, empty SVG paintable.
--   
--   <i>Since: 4.22</i>
svgNew :: (HasCallStack, MonadIO m) => m Svg

-- | Parses the SVG data in <i><tt>bytes</tt></i> and creates a paintable.
--   
--   <i>Since: 4.22</i>
svgNewFromBytes :: (HasCallStack, MonadIO m) => Bytes -> m Svg

-- | Parses the SVG data in the resource and creates a paintable.
--   
--   <i>Since: 4.22</i>
svgNewFromResource :: (HasCallStack, MonadIO m) => Text -> m Svg

-- | Stop any playing animations and state transitions.
--   
--   Animations can be paused and started repeatedly.
--   
--   <i>Since: 4.22</i>
svgPause :: (HasCallStack, MonadIO m, IsSvg a) => a -> m ()

-- | Start playing animations and state transitions.
--   
--   Animations can be paused and started repeatedly.
--   
--   <i>Since: 4.22</i>
svgPlay :: (HasCallStack, MonadIO m, IsSvg a) => a -> m ()

-- | Serializes the content of the renderer as SVG.
--   
--   The SVG will be similar to the orignally loaded one, but is not
--   guaranteed to be 100% identical.
--   
--   This function serializes the DOM, i.e. the results of parsing the SVG.
--   It does not reflect the effect of applying animations.
--   
--   <i>Since: 4.22</i>
svgSerialize :: (HasCallStack, MonadIO m, IsSvg a) => a -> m Bytes

-- | Enables or disables features of the SVG paintable.
--   
--   By default, all features are enabled.
--   
--   Note that this call only has an effect before the SVG is loaded.
--   
--   <i>Since: 4.22</i>
svgSetFeatures :: (HasCallStack, MonadIO m, IsSvg a) => a -> [SvgFeatures] -> m ()

-- | Sets a frame clock.
--   
--   Without a frame clock, GtkSvg will not advance animations.
--   
--   <i>Since: 4.22</i>
svgSetFrameClock :: (HasCallStack, MonadIO m, IsSvg a, IsFrameClock b) => a -> b -> m ()

-- | Sets the state of the paintable.
--   
--   Use <a>svgGetNStates</a> to find out what states <i><tt>self</tt></i>
--   has.
--   
--   If the paintable is currently playing, the state change will apply
--   transitions that are defined in the SVG. If the paintable is not
--   playing, the state change will take effect instantaneously.
--   
--   <i>Since: 4.22</i>
svgSetState :: (HasCallStack, MonadIO m, IsSvg a) => a -> Word32 -> m ()

-- | Sets the weight that is used when rendering.
--   
--   The weight affects the effective linewidth when stroking paths.
--   
--   The default value of -1 means to use the font weight from CSS.
--   
--   <i>Since: 4.22</i>
svgSetWeight :: (HasCallStack, MonadIO m, IsSvg a) => a -> Double -> m ()

-- | Serializes the paintable, and saves the result to a file.
--   
--   <i>Since: 4.22</i>
svgWriteToFile :: (HasCallStack, MonadIO m, IsSvg a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>features</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSvgFeatures :: (IsSvg o, MonadIO m) => [SvgFeatures] -> m (GValueConstruct o)

-- | Get the value of the “<tt>features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svg #features
--   </pre>
getSvgFeatures :: (MonadIO m, IsSvg o) => o -> m [SvgFeatures]

-- | Set the value of the “<tt>features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svg [ #features <a>:=</a> value ]
--   </pre>
setSvgFeatures :: (MonadIO m, IsSvg o) => o -> [SvgFeatures] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>playing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSvgPlaying :: (IsSvg o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>playing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svg #playing
--   </pre>
getSvgPlaying :: (MonadIO m, IsSvg o) => o -> m Bool

-- | Set the value of the “<tt>playing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svg [ #playing <a>:=</a> value ]
--   </pre>
setSvgPlaying :: (MonadIO m, IsSvg o) => o -> Bool -> m ()

-- | Set the value of the “<tt>resource</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #resource
--   </pre>
clearSvgResource :: (MonadIO m, IsSvg o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resource</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSvgResource :: (IsSvg o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svg #resource
--   </pre>
getSvgResource :: (MonadIO m, IsSvg o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svg [ #resource <a>:=</a> value ]
--   </pre>
setSvgResource :: (MonadIO m, IsSvg o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>state</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSvgState :: (IsSvg o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svg #state
--   </pre>
getSvgState :: (MonadIO m, IsSvg o) => o -> m Word32

-- | Set the value of the “<tt>state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svg [ #state <a>:=</a> value ]
--   </pre>
setSvgState :: (MonadIO m, IsSvg o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSvgWeight :: (IsSvg o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svg #weight
--   </pre>
getSvgWeight :: (MonadIO m, IsSvg o) => o -> m Double

-- | Set the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svg [ #weight <a>:=</a> value ]
--   </pre>
setSvgWeight :: (MonadIO m, IsSvg o) => o -> Double -> m ()

-- | Signals that an error occurred.
--   
--   Errors can occur both during parsing and during rendering.
--   
--   The expected error values are in the
--   [error<i><tt>gtk</tt></i>.SvgError] enumeration, context information
--   about the location of parsing errors can be obtained with the various
--   <tt>gtk_svg_error</tt> functions.
--   
--   Parsing errors are never fatal, so the parsing will resume after the
--   error. Errors may however cause parts of the given data or even all of
--   it to not be parsed at all. So it is a useful idea to check that the
--   parsing succeeds by connecting to this signal.
--   
--   ::: note This signal is emitted in the middle of parsing or rendering,
--   and if you handle it, you must be careful. Logging the errors you
--   receive is fine, but modifying the widget hierarchy or changing the
--   paintable state definitively isn't.
--   
--   If in doubt, defer to an idle.
--   
--   <i>Since: 4.22</i>
type SvgErrorCallback = GError -> IO ()

-- | Connect a signal handler for the <a>error</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> svg #error callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSvgError :: (IsSvg a, MonadIO m) => a -> ((?self :: a) => SvgErrorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>error</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> svg #error callback
--   </pre>
onSvgError :: (IsSvg a, MonadIO m) => a -> ((?self :: a) => SvgErrorCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Svg.Svg
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Svg.Svg
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Svg.Svg
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Svg.Svg)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Svg.Svg o) => GI.Gtk.Objects.Svg.IsSvg o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Svg.Svg
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Svg.Svg


-- | Can be applied to text contained in a <tt>GtkTextBuffer</tt>.
--   
--   You may wish to begin by reading the <a>text widget conceptual
--   overview</a>, which gives an overview of all the objects and data
--   types related to the text widget and how they work together.
--   
--   Tags should be in the <a>TextTagTable</a> for a given
--   <tt>GtkTextBuffer</tt> before using them with that buffer.
--   
--   <a>TextBuffer</a>.<tt><i>create_tag</i></tt>() is the best way to
--   create tags. See “gtk4-demo” for numerous examples.
--   
--   For each property of <tt>GtkTextTag</tt>, there is a “set” property,
--   e.g. “font-set” corresponds to “font”. These “set” properties reflect
--   whether a property has been set or not.
--   
--   They are maintained by GTK and you should not set them independently.
module GI.Gtk.Objects.TextTag

-- | Memory-managed wrapper type.
newtype TextTag
TextTag :: ManagedPtr TextTag -> TextTag

-- | Type class for types which can be safely cast to <a>TextTag</a>, for
--   instance with <a>toTextTag</a>.
class (GObject o, IsDescendantOf TextTag o) => IsTextTag o

-- | Cast to <a>TextTag</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTextTag :: (MonadIO m, IsTextTag o) => o -> m TextTag

-- | Emits the <a>TextTagTable::tagChanged</a> signal on the
--   <tt>GtkTextTagTable</tt> where the tag is included.
--   
--   The signal is already emitted when setting a <tt>GtkTextTag</tt>
--   property. This function is useful for a <tt>GtkTextTag</tt> subclass.
textTagChanged :: (HasCallStack, MonadIO m, IsTextTag a) => a -> Bool -> m ()

-- | Get the tag priority.
textTagGetPriority :: (HasCallStack, MonadIO m, IsTextTag a) => a -> m Int32

-- | Creates a <tt>GtkTextTag</tt>.
textTagNew :: (HasCallStack, MonadIO m) => Maybe Text -> m TextTag

-- | Sets the priority of a <tt>GtkTextTag</tt>.
--   
--   Valid priorities start at 0 and go to one less than
--   <a>textTagTableGetSize</a>. Each tag in a table has a unique priority;
--   setting the priority of one tag shifts the priorities of all the other
--   tags in the table to maintain a unique priority for each tag.
--   
--   Higher priority tags “win” if two tags both set the same text
--   attribute. When adding a tag to a tag table, it will be assigned the
--   highest priority in the table by default; so normally the precedence
--   of a set of tags is the order in which they were added to the table,
--   or created with <a>TextBuffer</a>.<tt><i>create_tag</i></tt>(), which
--   adds the tag to the buffer’s table automatically.
textTagSetPriority :: (HasCallStack, MonadIO m, IsTextTag a) => a -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accumulative-margin</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagAccumulativeMargin :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>accumulative-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #accumulativeMargin
--   </pre>
getTextTagAccumulativeMargin :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>accumulative-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #accumulativeMargin <a>:=</a> value ]
--   </pre>
setTextTagAccumulativeMargin :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>allow-breaks</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagAllowBreaks :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>allow-breaks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #allowBreaks
--   </pre>
getTextTagAllowBreaks :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>allow-breaks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #allowBreaks <a>:=</a> value ]
--   </pre>
setTextTagAllowBreaks :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>allow-breaks-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagAllowBreaksSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>allow-breaks-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #allowBreaksSet
--   </pre>
getTextTagAllowBreaksSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>allow-breaks-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #allowBreaksSet <a>:=</a> value ]
--   </pre>
setTextTagAllowBreaksSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>background</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #background
--   </pre>
clearTextTagBackground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagBackground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #background <a>:=</a> value ]
--   </pre>
setTextTagBackground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-full-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagBackgroundFullHeight :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-full-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundFullHeight
--   </pre>
getTextTagBackgroundFullHeight :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>background-full-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundFullHeight <a>:=</a> value ]
--   </pre>
setTextTagBackgroundFullHeight :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-full-height-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagBackgroundFullHeightSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-full-height-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundFullHeightSet
--   </pre>
getTextTagBackgroundFullHeightSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>background-full-height-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundFullHeightSet <a>:=</a> value ]
--   </pre>
setTextTagBackgroundFullHeightSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundRgba
--   </pre>
clearTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagBackgroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundRgba
--   </pre>
getTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundRgba <a>:=</a> value ]
--   </pre>
setTextTagBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagBackgroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #backgroundSet
--   </pre>
getTextTagBackgroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #backgroundSet <a>:=</a> value ]
--   </pre>
setTextTagBackgroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>direction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagDirection :: (IsTextTag o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #direction
--   </pre>
getTextTagDirection :: (MonadIO m, IsTextTag o) => o -> m TextDirection

-- | Set the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #direction <a>:=</a> value ]
--   </pre>
setTextTagDirection :: (MonadIO m, IsTextTag o) => o -> TextDirection -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagEditable :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #editable
--   </pre>
getTextTagEditable :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #editable <a>:=</a> value ]
--   </pre>
setTextTagEditable :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagEditableSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #editableSet
--   </pre>
getTextTagEditableSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #editableSet <a>:=</a> value ]
--   </pre>
setTextTagEditableSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fallback</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagFallback :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fallback
--   </pre>
getTextTagFallback :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fallback <a>:=</a> value ]
--   </pre>
setTextTagFallback :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fallback-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagFallbackSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fallback-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fallbackSet
--   </pre>
getTextTagFallbackSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>fallback-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fallbackSet <a>:=</a> value ]
--   </pre>
setTextTagFallbackSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>family</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #family
--   </pre>
clearTextTagFamily :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagFamily :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #family
--   </pre>
getTextTagFamily :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #family <a>:=</a> value ]
--   </pre>
setTextTagFamily :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagFamilySet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #familySet
--   </pre>
getTextTagFamilySet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #familySet <a>:=</a> value ]
--   </pre>
setTextTagFamilySet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>font</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #font
--   </pre>
clearTextTagFont :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagFont :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #font
--   </pre>
getTextTagFont :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #font <a>:=</a> value ]
--   </pre>
setTextTagFont :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Set the value of the “<tt>font-desc</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #fontDesc
--   </pre>
clearTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-desc</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagFontDesc :: (IsTextTag o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fontDesc
--   </pre>
getTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fontDesc <a>:=</a> value ]
--   </pre>
setTextTagFontDesc :: (MonadIO m, IsTextTag o) => o -> FontDescription -> m ()

-- | Set the value of the “<tt>font-features</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #fontFeatures
--   </pre>
clearTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-features</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagFontFeatures :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fontFeatures
--   </pre>
getTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fontFeatures <a>:=</a> value ]
--   </pre>
setTextTagFontFeatures :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-features-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagFontFeaturesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-features-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #fontFeaturesSet
--   </pre>
getTextTagFontFeaturesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>font-features-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #fontFeaturesSet <a>:=</a> value ]
--   </pre>
setTextTagFontFeaturesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>foreground</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #foreground
--   </pre>
clearTextTagForeground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagForeground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #foreground <a>:=</a> value ]
--   </pre>
setTextTagForeground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Set the value of the “<tt>foreground-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #foregroundRgba
--   </pre>
clearTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagForegroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #foregroundRgba
--   </pre>
getTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #foregroundRgba <a>:=</a> value ]
--   </pre>
setTextTagForegroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagForegroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #foregroundSet
--   </pre>
getTextTagForegroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #foregroundSet <a>:=</a> value ]
--   </pre>
setTextTagForegroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagIndent :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #indent
--   </pre>
getTextTagIndent :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #indent <a>:=</a> value ]
--   </pre>
setTextTagIndent :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagIndentSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>indent-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #indentSet
--   </pre>
getTextTagIndentSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>indent-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #indentSet <a>:=</a> value ]
--   </pre>
setTextTagIndentSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>insert-hyphens</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagInsertHyphens :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>insert-hyphens</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #insertHyphens
--   </pre>
getTextTagInsertHyphens :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>insert-hyphens</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #insertHyphens <a>:=</a> value ]
--   </pre>
setTextTagInsertHyphens :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>insert-hyphens-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagInsertHyphensSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>insert-hyphens-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #insertHyphensSet
--   </pre>
getTextTagInsertHyphensSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>insert-hyphens-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #insertHyphensSet <a>:=</a> value ]
--   </pre>
setTextTagInsertHyphensSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagInvisible :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #invisible
--   </pre>
getTextTagInvisible :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>invisible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #invisible <a>:=</a> value ]
--   </pre>
setTextTagInvisible :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagInvisibleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #invisibleSet
--   </pre>
getTextTagInvisibleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>invisible-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #invisibleSet <a>:=</a> value ]
--   </pre>
setTextTagInvisibleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justification</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagJustification :: (IsTextTag o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #justification
--   </pre>
getTextTagJustification :: (MonadIO m, IsTextTag o) => o -> m Justification

-- | Set the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #justification <a>:=</a> value ]
--   </pre>
setTextTagJustification :: (MonadIO m, IsTextTag o) => o -> Justification -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justification-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagJustificationSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>justification-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #justificationSet
--   </pre>
getTextTagJustificationSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>justification-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #justificationSet <a>:=</a> value ]
--   </pre>
setTextTagJustificationSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>language</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #language
--   </pre>
clearTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagLanguage :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #language
--   </pre>
getTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #language <a>:=</a> value ]
--   </pre>
setTextTagLanguage :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagLanguageSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #languageSet
--   </pre>
getTextTagLanguageSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #languageSet <a>:=</a> value ]
--   </pre>
setTextTagLanguageSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagLeftMargin :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #leftMargin
--   </pre>
getTextTagLeftMargin :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #leftMargin <a>:=</a> value ]
--   </pre>
setTextTagLeftMargin :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-margin-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagLeftMarginSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #leftMarginSet
--   </pre>
getTextTagLeftMarginSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>left-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #leftMarginSet <a>:=</a> value ]
--   </pre>
setTextTagLeftMarginSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>letter-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagLetterSpacing :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>letter-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #letterSpacing
--   </pre>
getTextTagLetterSpacing :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>letter-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #letterSpacing <a>:=</a> value ]
--   </pre>
setTextTagLetterSpacing :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>letter-spacing-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagLetterSpacingSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>letter-spacing-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #letterSpacingSet
--   </pre>
getTextTagLetterSpacingSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>letter-spacing-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #letterSpacingSet <a>:=</a> value ]
--   </pre>
setTextTagLetterSpacingSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>line-height</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagLineHeight :: (IsTextTag o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>line-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #lineHeight
--   </pre>
getTextTagLineHeight :: (MonadIO m, IsTextTag o) => o -> m Float

-- | Set the value of the “<tt>line-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #lineHeight <a>:=</a> value ]
--   </pre>
setTextTagLineHeight :: (MonadIO m, IsTextTag o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>line-height-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagLineHeightSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>line-height-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #lineHeightSet
--   </pre>
getTextTagLineHeightSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>line-height-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #lineHeightSet <a>:=</a> value ]
--   </pre>
setTextTagLineHeightSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagName :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #name
--   </pre>
getTextTagName :: (MonadIO m, IsTextTag o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overline</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagOverline :: (IsTextTag o, MonadIO m) => Overline -> m (GValueConstruct o)

-- | Get the value of the “<tt>overline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #overline
--   </pre>
getTextTagOverline :: (MonadIO m, IsTextTag o) => o -> m Overline

-- | Set the value of the “<tt>overline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #overline <a>:=</a> value ]
--   </pre>
setTextTagOverline :: (MonadIO m, IsTextTag o) => o -> Overline -> m ()

-- | Set the value of the “<tt>overline-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #overlineRgba
--   </pre>
clearTextTagOverlineRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overline-rgba</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagOverlineRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>overline-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #overlineRgba
--   </pre>
getTextTagOverlineRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>overline-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #overlineRgba <a>:=</a> value ]
--   </pre>
setTextTagOverlineRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overline-rgba-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagOverlineRgbaSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>overline-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #overlineRgbaSet
--   </pre>
getTextTagOverlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>overline-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #overlineRgbaSet <a>:=</a> value ]
--   </pre>
setTextTagOverlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overline-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagOverlineSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>overline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #overlineSet
--   </pre>
getTextTagOverlineSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>overline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #overlineSet <a>:=</a> value ]
--   </pre>
setTextTagOverlineSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>paragraph-background</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #paragraphBackground
--   </pre>
clearTextTagParagraphBackground :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paragraph-background</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagParagraphBackground :: (IsTextTag o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>paragraph-background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #paragraphBackground <a>:=</a> value ]
--   </pre>
setTextTagParagraphBackground :: (MonadIO m, IsTextTag o) => o -> Text -> m ()

-- | Set the value of the “<tt>paragraph-background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #paragraphBackgroundRgba
--   </pre>
clearTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paragraph-background-rgba</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagParagraphBackgroundRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>paragraph-background-rgba</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #paragraphBackgroundRgba
--   </pre>
getTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>paragraph-background-rgba</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #paragraphBackgroundRgba <a>:=</a> value ]
--   </pre>
setTextTagParagraphBackgroundRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paragraph-background-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagParagraphBackgroundSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>paragraph-background-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #paragraphBackgroundSet
--   </pre>
getTextTagParagraphBackgroundSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>paragraph-background-set</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #paragraphBackgroundSet <a>:=</a> value ]
--   </pre>
setTextTagParagraphBackgroundSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-above-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsAboveLines :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsAboveLines
--   </pre>
getTextTagPixelsAboveLines :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsAboveLines <a>:=</a> value ]
--   </pre>
setTextTagPixelsAboveLines :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-above-lines-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsAboveLinesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-above-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsAboveLinesSet
--   </pre>
getTextTagPixelsAboveLinesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>pixels-above-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsAboveLinesSet <a>:=</a> value ]
--   </pre>
setTextTagPixelsAboveLinesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-below-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsBelowLines :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsBelowLines
--   </pre>
getTextTagPixelsBelowLines :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsBelowLines <a>:=</a> value ]
--   </pre>
setTextTagPixelsBelowLines :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-below-lines-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsBelowLinesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-below-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsBelowLinesSet
--   </pre>
getTextTagPixelsBelowLinesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>pixels-below-lines-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsBelowLinesSet <a>:=</a> value ]
--   </pre>
setTextTagPixelsBelowLinesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-inside-wrap</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsInsideWrap :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsInsideWrap
--   </pre>
getTextTagPixelsInsideWrap :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsInsideWrap <a>:=</a> value ]
--   </pre>
setTextTagPixelsInsideWrap :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-inside-wrap-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagPixelsInsideWrapSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-inside-wrap-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #pixelsInsideWrapSet
--   </pre>
getTextTagPixelsInsideWrapSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>pixels-inside-wrap-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #pixelsInsideWrapSet <a>:=</a> value ]
--   </pre>
setTextTagPixelsInsideWrapSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagRightMargin :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #rightMargin
--   </pre>
getTextTagRightMargin :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #rightMargin <a>:=</a> value ]
--   </pre>
setTextTagRightMargin :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-margin-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagRightMarginSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #rightMarginSet
--   </pre>
getTextTagRightMarginSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>right-margin-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #rightMarginSet <a>:=</a> value ]
--   </pre>
setTextTagRightMarginSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagRise :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #rise
--   </pre>
getTextTagRise :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #rise <a>:=</a> value ]
--   </pre>
setTextTagRise :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagRiseSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #riseSet
--   </pre>
getTextTagRiseSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #riseSet <a>:=</a> value ]
--   </pre>
setTextTagRiseSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagScale :: (IsTextTag o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #scale
--   </pre>
getTextTagScale :: (MonadIO m, IsTextTag o) => o -> m Double

-- | Set the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #scale <a>:=</a> value ]
--   </pre>
setTextTagScale :: (MonadIO m, IsTextTag o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagScaleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #scaleSet
--   </pre>
getTextTagScaleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #scaleSet <a>:=</a> value ]
--   </pre>
setTextTagScaleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sentence</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagSentence :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sentence</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #sentence
--   </pre>
getTextTagSentence :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>sentence</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #sentence <a>:=</a> value ]
--   </pre>
setTextTagSentence :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sentence-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagSentenceSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sentence-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #sentenceSet
--   </pre>
getTextTagSentenceSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>sentence-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #sentenceSet <a>:=</a> value ]
--   </pre>
setTextTagSentenceSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-spaces</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagShowSpaces :: (IsTextTag o, MonadIO m) => [ShowFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-spaces</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #showSpaces
--   </pre>
getTextTagShowSpaces :: (MonadIO m, IsTextTag o) => o -> m [ShowFlags]

-- | Set the value of the “<tt>show-spaces</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #showSpaces <a>:=</a> value ]
--   </pre>
setTextTagShowSpaces :: (MonadIO m, IsTextTag o) => o -> [ShowFlags] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-spaces-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagShowSpacesSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-spaces-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #showSpacesSet
--   </pre>
getTextTagShowSpacesSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>show-spaces-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #showSpacesSet <a>:=</a> value ]
--   </pre>
setTextTagShowSpacesSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagSize :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #size
--   </pre>
getTextTagSize :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #size <a>:=</a> value ]
--   </pre>
setTextTagSize :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-points</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagSizePoints :: (IsTextTag o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #sizePoints
--   </pre>
getTextTagSizePoints :: (MonadIO m, IsTextTag o) => o -> m Double

-- | Set the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #sizePoints <a>:=</a> value ]
--   </pre>
setTextTagSizePoints :: (MonadIO m, IsTextTag o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagSizeSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #sizeSet
--   </pre>
getTextTagSizeSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #sizeSet <a>:=</a> value ]
--   </pre>
setTextTagSizeSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagStretch :: (IsTextTag o, MonadIO m) => Stretch -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #stretch
--   </pre>
getTextTagStretch :: (MonadIO m, IsTextTag o) => o -> m Stretch

-- | Set the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #stretch <a>:=</a> value ]
--   </pre>
setTextTagStretch :: (MonadIO m, IsTextTag o) => o -> Stretch -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagStretchSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #stretchSet
--   </pre>
getTextTagStretchSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #stretchSet <a>:=</a> value ]
--   </pre>
setTextTagStretchSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagStrikethrough :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethrough
--   </pre>
getTextTagStrikethrough :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethrough <a>:=</a> value ]
--   </pre>
setTextTagStrikethrough :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>strikethrough-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #strikethroughRgba
--   </pre>
clearTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-rgba</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagStrikethroughRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethroughRgba
--   </pre>
getTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>strikethrough-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethroughRgba <a>:=</a> value ]
--   </pre>
setTextTagStrikethroughRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-rgba-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagStrikethroughRgbaSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethroughRgbaSet
--   </pre>
getTextTagStrikethroughRgbaSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethroughRgbaSet <a>:=</a> value ]
--   </pre>
setTextTagStrikethroughRgbaSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagStrikethroughSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #strikethroughSet
--   </pre>
getTextTagStrikethroughSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #strikethroughSet <a>:=</a> value ]
--   </pre>
setTextTagStrikethroughSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagStyle :: (IsTextTag o, MonadIO m) => Style -> m (GValueConstruct o)

-- | Get the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #style
--   </pre>
getTextTagStyle :: (MonadIO m, IsTextTag o) => o -> m Style

-- | Set the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #style <a>:=</a> value ]
--   </pre>
setTextTagStyle :: (MonadIO m, IsTextTag o) => o -> Style -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagStyleSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #styleSet
--   </pre>
getTextTagStyleSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #styleSet <a>:=</a> value ]
--   </pre>
setTextTagStyleSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Set the value of the “<tt>tabs</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tabs
--   </pre>
clearTextTagTabs :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagTabs :: (IsTextTag o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #tabs
--   </pre>
getTextTagTabs :: (MonadIO m, IsTextTag o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #tabs <a>:=</a> value ]
--   </pre>
setTextTagTabs :: (MonadIO m, IsTextTag o) => o -> TabArray -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagTabsSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #tabsSet
--   </pre>
getTextTagTabsSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>tabs-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #tabsSet <a>:=</a> value ]
--   </pre>
setTextTagTabsSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-transform</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagTextTransform :: (IsTextTag o, MonadIO m) => TextTransform -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-transform</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #textTransform
--   </pre>
getTextTagTextTransform :: (MonadIO m, IsTextTag o) => o -> m TextTransform

-- | Set the value of the “<tt>text-transform</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #textTransform <a>:=</a> value ]
--   </pre>
setTextTagTextTransform :: (MonadIO m, IsTextTag o) => o -> TextTransform -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-transform-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagTextTransformSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-transform-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #textTransformSet
--   </pre>
getTextTagTextTransformSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>text-transform-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #textTransformSet <a>:=</a> value ]
--   </pre>
setTextTagTextTransformSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagUnderline :: (IsTextTag o, MonadIO m) => Underline -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underline
--   </pre>
getTextTagUnderline :: (MonadIO m, IsTextTag o) => o -> m Underline

-- | Set the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underline <a>:=</a> value ]
--   </pre>
setTextTagUnderline :: (MonadIO m, IsTextTag o) => o -> Underline -> m ()

-- | Set the value of the “<tt>underline-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #underlineRgba
--   </pre>
clearTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextTagUnderlineRgba :: (IsTextTag o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underlineRgba
--   </pre>
getTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>underline-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underlineRgba <a>:=</a> value ]
--   </pre>
setTextTagUnderlineRgba :: (MonadIO m, IsTextTag o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-rgba-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTagUnderlineRgbaSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underlineRgbaSet
--   </pre>
getTextTagUnderlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>underline-rgba-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underlineRgbaSet <a>:=</a> value ]
--   </pre>
setTextTagUnderlineRgbaSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagUnderlineSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #underlineSet
--   </pre>
getTextTagUnderlineSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #underlineSet <a>:=</a> value ]
--   </pre>
setTextTagUnderlineSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagVariant :: (IsTextTag o, MonadIO m) => Variant -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #variant
--   </pre>
getTextTagVariant :: (MonadIO m, IsTextTag o) => o -> m Variant

-- | Set the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #variant <a>:=</a> value ]
--   </pre>
setTextTagVariant :: (MonadIO m, IsTextTag o) => o -> Variant -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagVariantSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #variantSet
--   </pre>
getTextTagVariantSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #variantSet <a>:=</a> value ]
--   </pre>
setTextTagVariantSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagWeight :: (IsTextTag o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #weight
--   </pre>
getTextTagWeight :: (MonadIO m, IsTextTag o) => o -> m Int32

-- | Set the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #weight <a>:=</a> value ]
--   </pre>
setTextTagWeight :: (MonadIO m, IsTextTag o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagWeightSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #weightSet
--   </pre>
getTextTagWeightSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #weightSet <a>:=</a> value ]
--   </pre>
setTextTagWeightSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>word</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTagWord :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>word</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #word
--   </pre>
getTextTagWord :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>word</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #word <a>:=</a> value ]
--   </pre>
setTextTagWord :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>word-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagWordSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>word-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #wordSet
--   </pre>
getTextTagWordSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>word-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #wordSet <a>:=</a> value ]
--   </pre>
setTextTagWordSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextTagWrapMode :: (IsTextTag o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #wrapMode
--   </pre>
getTextTagWrapMode :: (MonadIO m, IsTextTag o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #wrapMode <a>:=</a> value ]
--   </pre>
setTextTagWrapMode :: (MonadIO m, IsTextTag o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextTagWrapModeSet :: (IsTextTag o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textTag #wrapModeSet
--   </pre>
getTextTagWrapModeSet :: (MonadIO m, IsTextTag o) => o -> m Bool

-- | Set the value of the “<tt>wrap-mode-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textTag [ #wrapModeSet <a>:=</a> value ]
--   </pre>
setTextTagWrapModeSet :: (MonadIO m, IsTextTag o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.TextTag.TextTag
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TextTag.TextTag
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TextTag.TextTag
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TextTag.TextTag)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TextTag.TextTag o) => GI.Gtk.Objects.TextTag.IsTextTag o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TextTag.TextTag
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TextTag.TextTag


-- | The type of item used by <tt>GtkTreeListModel</tt>.
--   
--   It allows navigating the model as a tree and modify the state of rows.
--   
--   <tt>GtkTreeListRow</tt> instances are created by a
--   <tt>GtkTreeListModel</tt> only when the
--   <a>TreeListModel:passthrough</a> property is not set.
--   
--   There are various support objects that can make use of
--   <tt>GtkTreeListRow</tt> objects, such as the <a>TreeExpander</a>
--   widget that allows displaying an icon to expand or collapse a row or
--   <a>TreeListRowSorter</a> that makes it possible to sort trees
--   properly.
module GI.Gtk.Objects.TreeListRow

-- | Memory-managed wrapper type.
newtype TreeListRow
TreeListRow :: ManagedPtr TreeListRow -> TreeListRow

-- | Type class for types which can be safely cast to <a>TreeListRow</a>,
--   for instance with <a>toTreeListRow</a>.
class (GObject o, IsDescendantOf TreeListRow o) => IsTreeListRow o

-- | Cast to <a>TreeListRow</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeListRow :: (MonadIO m, IsTreeListRow o) => o -> m TreeListRow

-- | If <i><tt>self</tt></i> is not expanded or <i><tt>position</tt></i> is
--   greater than the number of children, <a>Nothing</a> is returned.
treeListRowGetChildRow :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> Word32 -> m (Maybe TreeListRow)

-- | If the row is expanded, gets the model holding the children of
--   <i><tt>self</tt></i>.
--   
--   This model is the model created by the
--   [callback<i><tt>gtk</tt></i>.TreeListModelCreateModelFunc] and
--   contains the original items, no matter what value
--   <a>TreeListModel:passthrough</a> is set to.
treeListRowGetChildren :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> m (Maybe ListModel)

-- | Gets the depth of this row.
--   
--   Rows that correspond to items in the root model have a depth of zero,
--   rows corresponding to items of models of direct children of the root
--   model have a depth of 1 and so on.
--   
--   The depth of a row never changes until the row is removed from its
--   model at which point it will forever return 0.
treeListRowGetDepth :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> m Word32

-- | Gets if a row is currently expanded.
treeListRowGetExpanded :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> m Bool

-- | Gets the item corresponding to this row,
treeListRowGetItem :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> m (Maybe Object)

-- | Gets the row representing the parent for <i><tt>self</tt></i>.
--   
--   That is the row that would need to be collapsed to make this row
--   disappear.
--   
--   If <i><tt>self</tt></i> is a row corresponding to the root model,
--   <a>Nothing</a> is returned.
--   
--   The value returned by this function never changes until the row is
--   removed from its model at which point it will forever return
--   <a>Nothing</a>.
treeListRowGetParent :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> m (Maybe TreeListRow)

-- | Returns the position in the <tt>GtkTreeListModel</tt> that
--   <i><tt>self</tt></i> occupies at the moment.
treeListRowGetPosition :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> m Word32

-- | Checks if a row can be expanded.
--   
--   This does not mean that the row is actually expanded, this can be
--   checked with <a>treeListRowGetExpanded</a>.
--   
--   If a row is expandable never changes until the row is removed from its
--   model at which point it will forever return <a>False</a>.
treeListRowIsExpandable :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> m Bool

-- | Expands or collapses a row.
--   
--   If a row is expanded, the model of calling the
--   [callback<i><tt>gtk</tt></i>.TreeListModelCreateModelFunc] for the
--   row's item will be inserted after this row. If a row is collapsed,
--   those items will be removed from the model.
--   
--   If the row is not expandable, this function does nothing.
treeListRowSetExpanded :: (HasCallStack, MonadIO m, IsTreeListRow a) => a -> Bool -> m ()

-- | Get the value of the “<tt>children</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListRow #children
--   </pre>
getTreeListRowChildren :: (MonadIO m, IsTreeListRow o) => o -> m (Maybe ListModel)

-- | Get the value of the “<tt>depth</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListRow #depth
--   </pre>
getTreeListRowDepth :: (MonadIO m, IsTreeListRow o) => o -> m Word32

-- | Get the value of the “<tt>expandable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListRow #expandable
--   </pre>
getTreeListRowExpandable :: (MonadIO m, IsTreeListRow o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expanded</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeListRowExpanded :: (IsTreeListRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListRow #expanded
--   </pre>
getTreeListRowExpanded :: (MonadIO m, IsTreeListRow o) => o -> m Bool

-- | Set the value of the “<tt>expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeListRow [ #expanded <a>:=</a> value ]
--   </pre>
setTreeListRowExpanded :: (MonadIO m, IsTreeListRow o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListRow #item
--   </pre>
getTreeListRowItem :: (MonadIO m, IsTreeListRow o) => o -> m (Maybe Object)
instance GHC.Classes.Eq GI.Gtk.Objects.TreeListRow.TreeListRow
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeListRow.TreeListRow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeListRow.TreeListRow
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeListRow.TreeListRow)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeListRow.TreeListRow o) => GI.Gtk.Objects.TreeListRow.IsTreeListRow o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeListRow.TreeListRow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeListRow.TreeListRow


-- | Applies a gives sorter to the levels in a tree.
--   
--   Here is an example for setting up a column view with a tree model and
--   a <tt>GtkTreeListSorter</tt>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   column_sorter = gtk_column_view_get_sorter (view);
--   sorter = gtk_tree_list_row_sorter_new (g_object_ref (column_sorter));
--   sort_model = gtk_sort_list_model_new (tree_model, sorter);
--   selection = gtk_single_selection_new (sort_model);
--   gtk_column_view_set_model (view, G_LIST_MODEL (selection));
--   </pre>
module GI.Gtk.Objects.TreeListRowSorter

-- | Memory-managed wrapper type.
newtype TreeListRowSorter
TreeListRowSorter :: ManagedPtr TreeListRowSorter -> TreeListRowSorter

-- | Type class for types which can be safely cast to
--   <a>TreeListRowSorter</a>, for instance with
--   <a>toTreeListRowSorter</a>.
class (GObject o, IsDescendantOf TreeListRowSorter o) => IsTreeListRowSorter o

-- | Cast to <a>TreeListRowSorter</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toTreeListRowSorter :: (MonadIO m, IsTreeListRowSorter o) => o -> m TreeListRowSorter

-- | Returns the sorter used by <i><tt>self</tt></i>.
treeListRowSorterGetSorter :: (HasCallStack, MonadIO m, IsTreeListRowSorter a) => a -> m (Maybe Sorter)

-- | Create a special-purpose sorter that applies the sorting of
--   <i><tt>sorter</tt></i> to the levels of a <tt>GtkTreeListModel</tt>.
--   
--   Note that this sorter relies on <a>TreeListModel:passthrough</a> being
--   <a>False</a> as it can only sort <a>TreeListRow</a>s.
treeListRowSorterNew :: (HasCallStack, MonadIO m, IsSorter a) => Maybe a -> m TreeListRowSorter

-- | Sets the sorter to use for items with the same parent.
--   
--   This sorter will be passed the <a>TreeListRow:item</a> of the tree
--   list rows passed to <i><tt>self</tt></i>.
treeListRowSorterSetSorter :: (HasCallStack, MonadIO m, IsTreeListRowSorter a, IsSorter b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>sorter</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #sorter
--   </pre>
clearTreeListRowSorterSorter :: (MonadIO m, IsTreeListRowSorter o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sorter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeListRowSorterSorter :: (IsTreeListRowSorter o, MonadIO m, IsSorter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListRowSorter #sorter
--   </pre>
getTreeListRowSorterSorter :: (MonadIO m, IsTreeListRowSorter o) => o -> m (Maybe Sorter)

-- | Set the value of the “<tt>sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeListRowSorter [ #sorter <a>:=</a> value ]
--   </pre>
setTreeListRowSorterSorter :: (MonadIO m, IsTreeListRowSorter o, IsSorter a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.TreeListRowSorter.TreeListRowSorter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeListRowSorter.TreeListRowSorter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeListRowSorter.TreeListRowSorter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeListRowSorter.TreeListRowSorter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeListRowSorter.TreeListRowSorter o) => GI.Gtk.Objects.TreeListRowSorter.IsTreeListRowSorter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeListRowSorter.TreeListRowSorter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeListRowSorter.TreeListRowSorter


-- | Wraps a list of references to <a>Accessible</a> objects.
--   
--   <i>Since: 4.14</i>
module GI.Gtk.Structs.AccessibleList

-- | Memory-managed wrapper type.
newtype AccessibleList
AccessibleList :: ManagedPtr AccessibleList -> AccessibleList

-- | Gets the list of objects this boxed type holds.
--   
--   <i>Since: 4.14</i>
accessibleListGetObjects :: (HasCallStack, MonadIO m) => AccessibleList -> m [Accessible]

-- | Allocates a new list of accessible objects.
--   
--   <i>Since: 4.14</i>
accessibleListNewFromArray :: (HasCallStack, MonadIO m) => [Accessible] -> m AccessibleList

-- | Allocates a new <tt>GtkAccessibleList</tt>, doing a shallow copy of
--   the passed list of accessible objects
--   
--   <i>Since: 4.14</i>
accessibleListNewFromList :: (HasCallStack, MonadIO m, IsAccessible a) => [a] -> m AccessibleList
instance GHC.Classes.Eq GI.Gtk.Structs.AccessibleList.AccessibleList
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.AccessibleList.AccessibleList
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.AccessibleList.AccessibleList
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.AccessibleList.AccessibleList)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.AccessibleList.AccessibleList
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.AccessibleList.AccessibleList


-- | A range inside the text of an accessible object.
--   
--   <i>Since: 4.14</i>
module GI.Gtk.Structs.AccessibleTextRange

-- | Memory-managed wrapper type.
newtype AccessibleTextRange
AccessibleTextRange :: ManagedPtr AccessibleTextRange -> AccessibleTextRange

-- | Construct a <a>AccessibleTextRange</a> struct initialized to zero.
newZeroAccessibleTextRange :: MonadIO m => m AccessibleTextRange

-- | Get the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accessibleTextRange #length
--   </pre>
getAccessibleTextRangeLength :: MonadIO m => AccessibleTextRange -> m CSize

-- | Set the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accessibleTextRange [ #length <a>:=</a> value ]
--   </pre>
setAccessibleTextRangeLength :: MonadIO m => AccessibleTextRange -> CSize -> m ()

-- | Get the value of the “<tt>start</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> accessibleTextRange #start
--   </pre>
getAccessibleTextRangeStart :: MonadIO m => AccessibleTextRange -> m CSize

-- | Set the value of the “<tt>start</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> accessibleTextRange [ #start <a>:=</a> value ]
--   </pre>
setAccessibleTextRangeStart :: MonadIO m => AccessibleTextRange -> CSize -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.AccessibleTextRange.AccessibleTextRange
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.AccessibleTextRange.AccessibleTextRange
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.AccessibleTextRange.AccessibleTextRange tag
instance GHC.Classes.Eq GI.Gtk.Structs.AccessibleTextRange.AccessibleTextRange
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.AccessibleTextRange.AccessibleTextRange


-- | Represents a link (i.e. a uri).
--   
--   A widget that contains one or more links should implement the
--   <a>AccessibleHypertext</a> interface and return
--   `GtkAccessibleHyperlink] objects for each of the links.
--   
--   <i>Since: 4.22</i>
module GI.Gtk.Objects.AccessibleHyperlink

-- | Memory-managed wrapper type.
newtype AccessibleHyperlink
AccessibleHyperlink :: ManagedPtr AccessibleHyperlink -> AccessibleHyperlink

-- | Type class for types which can be safely cast to
--   <a>AccessibleHyperlink</a>, for instance with
--   <a>toAccessibleHyperlink</a>.
class (GObject o, IsDescendantOf AccessibleHyperlink o) => IsAccessibleHyperlink o

-- | Cast to <a>AccessibleHyperlink</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toAccessibleHyperlink :: (MonadIO m, IsAccessibleHyperlink o) => o -> m AccessibleHyperlink

-- | Creates an accessible object that represents a hyperlink.
--   
--   This is meant to be used with an implementation of the
--   <a>AccessibleHypertext</a> interface.
--   
--   <i>Since: 4.22</i>
accessibleHyperlinkNew :: (HasCallStack, MonadIO m, IsAccessibleHypertext a) => a -> Word32 -> Text -> AccessibleTextRange -> m AccessibleHyperlink

-- | Sets a platform state on the accessible.
--   
--   <i>Since: 4.22</i>
accessibleHyperlinkSetPlatformState :: (HasCallStack, MonadIO m, IsAccessibleHyperlink a) => a -> AccessiblePlatformState -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.AccessibleHyperlink.AccessibleHyperlink
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AccessibleHyperlink.AccessibleHyperlink
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AccessibleHyperlink.AccessibleHyperlink
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AccessibleHyperlink.AccessibleHyperlink o) => GI.Gtk.Objects.AccessibleHyperlink.IsAccessibleHyperlink o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AccessibleHyperlink.AccessibleHyperlink)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AccessibleHyperlink.AccessibleHyperlink
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AccessibleHyperlink.AccessibleHyperlink


-- | A set of unsigned integers.
--   
--   Another name for this data structure is “bitmap”.
--   
--   The current implementation is based on <a>roaring bitmaps</a>.
--   
--   A bitset allows adding a set of integers and provides support for set
--   operations like unions, intersections and checks for equality or if a
--   value is contained in the set. <tt>GtkBitset</tt> also contains
--   various functions to query metadata about the bitset, such as the
--   minimum or maximum values or its size.
--   
--   The fastest way to iterate values in a bitset is <a>BitsetIter</a>.
--   
--   The main use case for <tt>GtkBitset</tt> is implementing complex
--   selections for <a>SelectionModel</a>.
module GI.Gtk.Structs.Bitset

-- | Memory-managed wrapper type.
newtype Bitset
Bitset :: ManagedPtr Bitset -> Bitset

-- | Adds <i><tt>value</tt></i> to <i><tt>self</tt></i> if it wasn't part
--   of it before.
bitsetAdd :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> m Bool

-- | Adds all values from <i><tt>start</tt></i> (inclusive) to
--   <i><tt>start</tt></i> + <i><tt>nItems</tt></i> (exclusive) in
--   <i><tt>self</tt></i>.
bitsetAddRange :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> m ()

-- | Adds the closed range [<i><tt>first</tt></i>, <i><tt>last</tt></i>],
--   so <i><tt>first</tt></i>, <i><tt>last</tt></i> and all values in
--   between. <i><tt>first</tt></i> must be smaller than
--   <i><tt>last</tt></i>.
bitsetAddRangeClosed :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> m ()

-- | Interprets the values as a 2-dimensional boolean grid with the given
--   <i><tt>stride</tt></i> and inside that grid, adds a rectangle with the
--   given <i><tt>width</tt></i> and <i><tt>height</tt></i>.
bitsetAddRectangle :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> Word32 -> Word32 -> m ()

-- | Checks if the given <i><tt>value</tt></i> has been added to
--   <i><tt>self</tt></i>
bitsetContains :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> m Bool

-- | Creates a copy of <i><tt>self</tt></i>.
bitsetCopy :: (HasCallStack, MonadIO m) => Bitset -> m Bitset

-- | Sets <i><tt>self</tt></i> to be the symmetric difference of
--   <i><tt>self</tt></i> and <i><tt>other</tt></i>.
--   
--   The symmetric difference is set <i><tt>self</tt></i> to contain all
--   values that were either contained in <i><tt>self</tt></i> or in
--   <i><tt>other</tt></i>, but not in both. This operation is also called
--   an XOR.
--   
--   It is allowed for <i><tt>self</tt></i> and <i><tt>other</tt></i> to be
--   the same bitset. The bitset will be emptied in that case.
bitsetDifference :: (HasCallStack, MonadIO m) => Bitset -> Bitset -> m ()

-- | Returns <a>True</a> if <i><tt>self</tt></i> and <i><tt>other</tt></i>
--   contain the same values.
bitsetEquals :: (HasCallStack, MonadIO m) => Bitset -> Bitset -> m Bool

-- | Returns the largest value in <i><tt>self</tt></i>.
--   
--   If <i><tt>self</tt></i> is empty, 0 is returned.
bitsetGetMaximum :: (HasCallStack, MonadIO m) => Bitset -> m Word32

-- | Returns the smallest value in <i><tt>self</tt></i>.
--   
--   If <i><tt>self</tt></i> is empty, <tt>G_MAXUINT</tt> is returned.
bitsetGetMinimum :: (HasCallStack, MonadIO m) => Bitset -> m Word32

-- | Returns the value of the <i><tt>nth</tt></i> item in self.
--   
--   If <i><tt>nth</tt></i> is &gt;= the size of <i><tt>self</tt></i>, 0 is
--   returned.
bitsetGetNth :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> m Word32

-- | Gets the number of values that were added to the set.
--   
--   For example, if the set is empty, 0 is returned.
--   
--   Note that this function returns a <tt>guint64</tt>, because when all
--   values are set, the return value is <tt>G_MAXUINT + 1</tt>. Unless you
--   are sure this cannot happen (it can't with <tt>GListModel</tt>), be
--   sure to use a 64bit type.
bitsetGetSize :: (HasCallStack, MonadIO m) => Bitset -> m Word64

-- | Gets the number of values that are part of the set from
--   <i><tt>first</tt></i> to <i><tt>last</tt></i> (inclusive).
--   
--   Note that this function returns a <tt>guint64</tt>, because when all
--   values are set, the return value is <tt>G_MAXUINT + 1</tt>. Unless you
--   are sure this cannot happen (it can't with <tt>GListModel</tt>), be
--   sure to use a 64bit type.
bitsetGetSizeInRange :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> m Word64

-- | Sets <i><tt>self</tt></i> to be the intersection of
--   <i><tt>self</tt></i> and <i><tt>other</tt></i>.
--   
--   In other words, remove all values from <i><tt>self</tt></i> that are
--   not part of <i><tt>other</tt></i>.
--   
--   It is allowed for <i><tt>self</tt></i> and <i><tt>other</tt></i> to be
--   the same bitset. Nothing will happen in that case.
bitsetIntersect :: (HasCallStack, MonadIO m) => Bitset -> Bitset -> m ()

-- | Check if no value is contained in bitset.
bitsetIsEmpty :: (HasCallStack, MonadIO m) => Bitset -> m Bool

-- | Creates a new empty bitset.
bitsetNewEmpty :: (HasCallStack, MonadIO m) => m Bitset

-- | Creates a bitset with the given range set.
bitsetNewRange :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> m Bitset

-- | Acquires a reference on the given <tt>GtkBitset</tt>.
bitsetRef :: (HasCallStack, MonadIO m) => Bitset -> m Bitset

-- | Removes <i><tt>value</tt></i> from <i><tt>self</tt></i> if it was part
--   of it before.
bitsetRemove :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> m Bool

-- | Removes all values from the bitset so that it is empty again.
bitsetRemoveAll :: (HasCallStack, MonadIO m) => Bitset -> m ()

-- | Removes all values from <i><tt>start</tt></i> (inclusive) to
--   <i><tt>start</tt></i> + <i><tt>nItems</tt></i> (exclusive) in
--   <i><tt>self</tt></i>.
bitsetRemoveRange :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> m ()

-- | Removes the closed range [<i><tt>first</tt></i>,
--   <i><tt>last</tt></i>], so <i><tt>first</tt></i>, <i><tt>last</tt></i>
--   and all values in between. <i><tt>first</tt></i> must be smaller than
--   <i><tt>last</tt></i>.
bitsetRemoveRangeClosed :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> m ()

-- | Interprets the values as a 2-dimensional boolean grid with the given
--   <i><tt>stride</tt></i> and inside that grid, removes a rectangle with
--   the given <i><tt>width</tt></i> and <i><tt>height</tt></i>.
bitsetRemoveRectangle :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> Word32 -> Word32 -> m ()

-- | Shifts all values in <i><tt>self</tt></i> to the left by
--   <i><tt>amount</tt></i>.
--   
--   Values smaller than <i><tt>amount</tt></i> are discarded.
bitsetShiftLeft :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> m ()

-- | Shifts all values in <i><tt>self</tt></i> to the right by
--   <i><tt>amount</tt></i>.
--   
--   Values that end up too large to be held in a <tt><i>guint</i></tt> are
--   discarded.
bitsetShiftRight :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> m ()

-- | This is a support function for <tt>GListModel</tt> handling, by
--   mirroring the <tt>GlistModel::items-changed</tt> signal.
--   
--   First, it "cuts" the values from <i><tt>position</tt></i> to
--   <i><tt>removed</tt></i> from the bitset. That is, it removes all those
--   values and shifts all larger values to the left by
--   <i><tt>removed</tt></i> places.
--   
--   Then, it "pastes" new room into the bitset by shifting all values
--   larger than <i><tt>position</tt></i> by <i><tt>added</tt></i> spaces
--   to the right. This frees up space that can then be filled.
bitsetSplice :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> Word32 -> Word32 -> m ()

-- | Sets <i><tt>self</tt></i> to be the subtraction of
--   <i><tt>other</tt></i> from <i><tt>self</tt></i>.
--   
--   In other words, remove all values from <i><tt>self</tt></i> that are
--   part of <i><tt>other</tt></i>.
--   
--   It is allowed for <i><tt>self</tt></i> and <i><tt>other</tt></i> to be
--   the same bitset. The bitset will be emptied in that case.
bitsetSubtract :: (HasCallStack, MonadIO m) => Bitset -> Bitset -> m ()

-- | Sets <i><tt>self</tt></i> to be the union of <i><tt>self</tt></i> and
--   <i><tt>other</tt></i>.
--   
--   That is, add all values from <i><tt>other</tt></i> into
--   <i><tt>self</tt></i> that weren't part of it.
--   
--   It is allowed for <i><tt>self</tt></i> and <i><tt>other</tt></i> to be
--   the same bitset. Nothing will happen in that case.
bitsetUnion :: (HasCallStack, MonadIO m) => Bitset -> Bitset -> m ()

-- | Releases a reference on the given <tt>GtkBitset</tt>.
--   
--   If the reference was the last, the resources associated to the
--   <i><tt>self</tt></i> are freed.
bitsetUnref :: (HasCallStack, MonadIO m) => Bitset -> m ()
instance GHC.Classes.Eq GI.Gtk.Structs.Bitset.Bitset
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.Bitset.Bitset
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.Bitset.Bitset
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.Bitset.Bitset)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.Bitset.Bitset
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.Bitset.Bitset


-- | A selection model that allows selecting a single item.
--   
--   Note that the selection is *persistent* -- if the selected item is
--   removed and re-added in the same <a>ListModel::itemsChanged</a>
--   emission, it stays selected. In particular, this means that changing
--   the sort order of an underlying sort model will preserve the
--   selection.
module GI.Gtk.Objects.SingleSelection

-- | Memory-managed wrapper type.
newtype SingleSelection
SingleSelection :: ManagedPtr SingleSelection -> SingleSelection

-- | Type class for types which can be safely cast to
--   <a>SingleSelection</a>, for instance with <a>toSingleSelection</a>.
class (GObject o, IsDescendantOf SingleSelection o) => IsSingleSelection o

-- | Cast to <a>SingleSelection</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSingleSelection :: (MonadIO m, IsSingleSelection o) => o -> m SingleSelection

-- | Checks if autoselect has been enabled or disabled via
--   <a>singleSelectionSetAutoselect</a>.
singleSelectionGetAutoselect :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> m Bool

-- | If <a>True</a>, <a>selectionModelUnselectItem</a> is supported and
--   allows unselecting the selected item.
singleSelectionGetCanUnselect :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> m Bool

-- | Gets the model that <i><tt>self</tt></i> is wrapping.
singleSelectionGetModel :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> m (Maybe ListModel)

-- | Gets the position of the selected item.
--   
--   If no item is selected, <a>INVALID_LIST_POSITION</a> is returned.
singleSelectionGetSelected :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> m Word32

-- | Gets the selected item.
--   
--   If no item is selected, <a>Nothing</a> is returned.
singleSelectionGetSelectedItem :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> m (Maybe Object)

-- | Creates a new selection to handle <i><tt>model</tt></i>.
singleSelectionNew :: (HasCallStack, MonadIO m, IsListModel a) => Maybe a -> m SingleSelection

-- | Enables or disables autoselect.
--   
--   If <i><tt>autoselect</tt></i> is <a>True</a>, <i><tt>self</tt></i>
--   will enforce that an item is always selected. It will select a new
--   item when the currently selected item is deleted and it will disallow
--   unselecting the current item.
singleSelectionSetAutoselect :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> Bool -> m ()

-- | If <a>True</a>, unselecting the current item via
--   <a>selectionModelUnselectItem</a> is supported.
--   
--   Note that setting <a>SingleSelection:autoselect</a> will cause
--   unselecting to not work, so it practically makes no sense to set both
--   at the same time.
singleSelectionSetCanUnselect :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> Bool -> m ()

-- | Sets the model that <i><tt>self</tt></i> should wrap.
--   
--   If <i><tt>model</tt></i> is <a>Nothing</a>, <i><tt>self</tt></i> will
--   be empty.
singleSelectionSetModel :: (HasCallStack, MonadIO m, IsSingleSelection a, IsListModel b) => a -> Maybe b -> m ()

-- | Selects the item at the given position.
--   
--   If the list does not have an item at <i><tt>position</tt></i> or
--   <a>INVALID_LIST_POSITION</a> is given, the behavior depends on the
--   value of the <a>SingleSelection:autoselect</a> property: If it is set,
--   no change will occur and the old item will stay selected. If it is
--   unset, the selection will be unset and no item will be selected. This
--   also applies if <a>SingleSelection:canUnselect</a> is set to
--   <a>False</a>.
singleSelectionSetSelected :: (HasCallStack, MonadIO m, IsSingleSelection a) => a -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>autoselect</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSingleSelectionAutoselect :: (IsSingleSelection o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>autoselect</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> singleSelection #autoselect
--   </pre>
getSingleSelectionAutoselect :: (MonadIO m, IsSingleSelection o) => o -> m Bool

-- | Set the value of the “<tt>autoselect</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> singleSelection [ #autoselect <a>:=</a> value ]
--   </pre>
setSingleSelectionAutoselect :: (MonadIO m, IsSingleSelection o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-unselect</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSingleSelectionCanUnselect :: (IsSingleSelection o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-unselect</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> singleSelection #canUnselect
--   </pre>
getSingleSelectionCanUnselect :: (MonadIO m, IsSingleSelection o) => o -> m Bool

-- | Set the value of the “<tt>can-unselect</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> singleSelection [ #canUnselect <a>:=</a> value ]
--   </pre>
setSingleSelectionCanUnselect :: (MonadIO m, IsSingleSelection o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> singleSelection #itemType
--   </pre>
getSingleSelectionItemType :: (MonadIO m, IsSingleSelection o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearSingleSelectionModel :: (MonadIO m, IsSingleSelection o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSingleSelectionModel :: (IsSingleSelection o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> singleSelection #model
--   </pre>
getSingleSelectionModel :: (MonadIO m, IsSingleSelection o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> singleSelection [ #model <a>:=</a> value ]
--   </pre>
setSingleSelectionModel :: (MonadIO m, IsSingleSelection o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> singleSelection #nItems
--   </pre>
getSingleSelectionNItems :: (MonadIO m, IsSingleSelection o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selected</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSingleSelectionSelected :: (IsSingleSelection o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>selected</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> singleSelection #selected
--   </pre>
getSingleSelectionSelected :: (MonadIO m, IsSingleSelection o) => o -> m Word32

-- | Set the value of the “<tt>selected</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> singleSelection [ #selected <a>:=</a> value ]
--   </pre>
setSingleSelectionSelected :: (MonadIO m, IsSingleSelection o) => o -> Word32 -> m ()

-- | Get the value of the “<tt>selected-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> singleSelection #selectedItem
--   </pre>
getSingleSelectionSelectedItem :: (MonadIO m, IsSingleSelection o) => o -> m (Maybe Object)
instance GHC.Classes.Eq GI.Gtk.Objects.SingleSelection.SingleSelection
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SingleSelection.SingleSelection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SingleSelection.SingleSelection
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SingleSelection.SingleSelection)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SingleSelection.SingleSelection o) => GI.Gtk.Objects.SingleSelection.IsSingleSelection o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SingleSelection.SingleSelection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SingleSelection.SingleSelection


-- | A list model that presents the selection from a
--   <tt>GtkSelectionModel</tt>.
module GI.Gtk.Objects.SelectionFilterModel

-- | Memory-managed wrapper type.
newtype SelectionFilterModel
SelectionFilterModel :: ManagedPtr SelectionFilterModel -> SelectionFilterModel

-- | Type class for types which can be safely cast to
--   <a>SelectionFilterModel</a>, for instance with
--   <a>toSelectionFilterModel</a>.
class (GObject o, IsDescendantOf SelectionFilterModel o) => IsSelectionFilterModel o

-- | Cast to <a>SelectionFilterModel</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toSelectionFilterModel :: (MonadIO m, IsSelectionFilterModel o) => o -> m SelectionFilterModel

-- | Gets the model currently filtered or <a>Nothing</a> if none.
selectionFilterModelGetModel :: (HasCallStack, MonadIO m, IsSelectionFilterModel a) => a -> m (Maybe SelectionModel)

-- | Creates a new <tt>GtkSelectionFilterModel</tt> that will include the
--   selected items from the underlying selection model.
selectionFilterModelNew :: (HasCallStack, MonadIO m, IsSelectionModel a) => Maybe a -> m SelectionFilterModel

-- | Sets the model to be filtered.
--   
--   Note that GTK makes no effort to ensure that <i><tt>model</tt></i>
--   conforms to the item type of <i><tt>self</tt></i>. It assumes that the
--   caller knows what they are doing and have set up an appropriate filter
--   to ensure that item types match.
selectionFilterModelSetModel :: (HasCallStack, MonadIO m, IsSelectionFilterModel a, IsSelectionModel b) => a -> Maybe b -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> selectionFilterModel #itemType
--   </pre>
getSelectionFilterModelItemType :: (MonadIO m, IsSelectionFilterModel o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearSelectionFilterModelModel :: (MonadIO m, IsSelectionFilterModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSelectionFilterModelModel :: (IsSelectionFilterModel o, MonadIO m, IsSelectionModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> selectionFilterModel #model
--   </pre>
getSelectionFilterModelModel :: (MonadIO m, IsSelectionFilterModel o) => o -> m (Maybe SelectionModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> selectionFilterModel [ #model <a>:=</a> value ]
--   </pre>
setSelectionFilterModelModel :: (MonadIO m, IsSelectionFilterModel o, IsSelectionModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> selectionFilterModel #nItems
--   </pre>
getSelectionFilterModelNItems :: (MonadIO m, IsSelectionFilterModel o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.SelectionFilterModel.SelectionFilterModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SelectionFilterModel.SelectionFilterModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SelectionFilterModel.SelectionFilterModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SelectionFilterModel.SelectionFilterModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SelectionFilterModel.SelectionFilterModel o) => GI.Gtk.Objects.SelectionFilterModel.IsSelectionFilterModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SelectionFilterModel.SelectionFilterModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SelectionFilterModel.SelectionFilterModel


-- | A selection model that does not allow selecting anything.
--   
--   This model is meant to be used as a simple wrapper around a
--   <tt>GListModel</tt> when a <tt>GtkSelectionModel</tt> is required.
--   
--   <tt>GtkNoSelection</tt> passes through sections from the underlying
--   model.
module GI.Gtk.Objects.NoSelection

-- | Memory-managed wrapper type.
newtype NoSelection
NoSelection :: ManagedPtr NoSelection -> NoSelection

-- | Type class for types which can be safely cast to <a>NoSelection</a>,
--   for instance with <a>toNoSelection</a>.
class (GObject o, IsDescendantOf NoSelection o) => IsNoSelection o

-- | Cast to <a>NoSelection</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNoSelection :: (MonadIO m, IsNoSelection o) => o -> m NoSelection

-- | Gets the model that <i><tt>self</tt></i> is wrapping.
noSelectionGetModel :: (HasCallStack, MonadIO m, IsNoSelection a) => a -> m (Maybe ListModel)

-- | Creates a new selection to handle <i><tt>model</tt></i>.
noSelectionNew :: (HasCallStack, MonadIO m, IsListModel a) => Maybe a -> m NoSelection

-- | Sets the model that <i><tt>self</tt></i> should wrap.
--   
--   If <i><tt>model</tt></i> is <a>Nothing</a>, this model will be empty.
noSelectionSetModel :: (HasCallStack, MonadIO m, IsNoSelection a, IsListModel b) => a -> Maybe b -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> noSelection #itemType
--   </pre>
getNoSelectionItemType :: (MonadIO m, IsNoSelection o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearNoSelectionModel :: (MonadIO m, IsNoSelection o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNoSelectionModel :: (IsNoSelection o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> noSelection #model
--   </pre>
getNoSelectionModel :: (MonadIO m, IsNoSelection o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> noSelection [ #model <a>:=</a> value ]
--   </pre>
setNoSelectionModel :: (MonadIO m, IsNoSelection o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> noSelection #nItems
--   </pre>
getNoSelectionNItems :: (MonadIO m, IsNoSelection o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.NoSelection.NoSelection
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.NoSelection.NoSelection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.NoSelection.NoSelection
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.NoSelection.NoSelection)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.NoSelection.NoSelection o) => GI.Gtk.Objects.NoSelection.IsNoSelection o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.NoSelection.NoSelection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.NoSelection.NoSelection


-- | A selection model that allows selecting multiple elements.
module GI.Gtk.Objects.MultiSelection

-- | Memory-managed wrapper type.
newtype MultiSelection
MultiSelection :: ManagedPtr MultiSelection -> MultiSelection

-- | Type class for types which can be safely cast to
--   <a>MultiSelection</a>, for instance with <a>toMultiSelection</a>.
class (GObject o, IsDescendantOf MultiSelection o) => IsMultiSelection o

-- | Cast to <a>MultiSelection</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMultiSelection :: (MonadIO m, IsMultiSelection o) => o -> m MultiSelection

-- | Returns the underlying model of <i><tt>self</tt></i>.
multiSelectionGetModel :: (HasCallStack, MonadIO m, IsMultiSelection a) => a -> m (Maybe ListModel)

-- | Creates a new selection to handle <i><tt>model</tt></i>.
multiSelectionNew :: (HasCallStack, MonadIO m, IsListModel a) => Maybe a -> m MultiSelection

-- | Sets the model that <i><tt>self</tt></i> should wrap.
--   
--   If <i><tt>model</tt></i> is <a>Nothing</a>, <i><tt>self</tt></i> will
--   be empty.
multiSelectionSetModel :: (HasCallStack, MonadIO m, IsMultiSelection a, IsListModel b) => a -> Maybe b -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> multiSelection #itemType
--   </pre>
getMultiSelectionItemType :: (MonadIO m, IsMultiSelection o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearMultiSelectionModel :: (MonadIO m, IsMultiSelection o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMultiSelectionModel :: (IsMultiSelection o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> multiSelection #model
--   </pre>
getMultiSelectionModel :: (MonadIO m, IsMultiSelection o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> multiSelection [ #model <a>:=</a> value ]
--   </pre>
setMultiSelectionModel :: (MonadIO m, IsMultiSelection o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> multiSelection #nItems
--   </pre>
getMultiSelectionNItems :: (MonadIO m, IsMultiSelection o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.MultiSelection.MultiSelection
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MultiSelection.MultiSelection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MultiSelection.MultiSelection
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MultiSelection.MultiSelection)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MultiSelection.MultiSelection o) => GI.Gtk.Objects.MultiSelection.IsMultiSelection o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MultiSelection.MultiSelection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MultiSelection.MultiSelection


-- | An interface that adds support for selection to list models.
--   
--   This support is then used by widgets using list models to add the
--   ability to select and unselect various items.
--   
--   GTK provides default implementations of the most common selection
--   modes such as <a>SingleSelection</a>, so you will only need to
--   implement this interface if you want detailed control about how
--   selections should be handled.
--   
--   A <tt>GtkSelectionModel</tt> supports a single boolean per item
--   indicating if an item is selected or not. This can be queried via
--   <a>selectionModelIsSelected</a>. When the selected state of one or
--   more items changes, the model will emit the
--   <a>SelectionModel::selectionChanged</a> signal by calling the
--   <a>selectionModelSelectionChanged</a> function. The positions given in
--   that signal may have their selection state changed, though that is not
--   a requirement. If new items added to the model via the
--   <a>ListModel::itemsChanged</a> signal are selected or not is up to the
--   implementation.
--   
--   Note that items added via <a>ListModel::itemsChanged</a> may already
--   be selected and no <a>SelectionModel::selectionChanged</a> will be
--   emitted for them. So to track which items are selected, it is
--   necessary to listen to both signals.
--   
--   Additionally, the interface can expose functionality to select and
--   unselect items. If these functions are implemented, GTK's list widgets
--   will allow users to select and unselect items. However,
--   <tt>GtkSelectionModel</tt>s are free to only implement them partially
--   or not at all. In that case the widgets will not support the
--   unimplemented operations.
--   
--   When selecting or unselecting is supported by a model, the return
--   values of the selection functions do *not* indicate if selection or
--   unselection happened. They are only meant to indicate complete
--   failure, like when this mode of selecting is not supported by the
--   model.
--   
--   Selections may happen asynchronously, so the only reliable way to find
--   out when an item was selected is to listen to the signals that
--   indicate selection.
module GI.Gtk.Interfaces.SelectionModel

-- | Memory-managed wrapper type.
newtype SelectionModel
SelectionModel :: ManagedPtr SelectionModel -> SelectionModel

-- | Type class for types which can be safely cast to
--   <a>SelectionModel</a>, for instance with <a>toSelectionModel</a>.
class (GObject o, IsDescendantOf SelectionModel o) => IsSelectionModel o

-- | Cast to <a>SelectionModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSelectionModel :: (MonadIO m, IsSelectionModel o) => o -> m SelectionModel

-- | Gets the set containing all currently selected items in the model.
--   
--   This function may be slow, so if you are only interested in single
--   item, consider using <a>selectionModelIsSelected</a> or if you are
--   only interested in a few, consider
--   <a>selectionModelGetSelectionInRange</a>.
selectionModelGetSelection :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> m Bitset

-- | Gets the set of selected items in a range.
--   
--   This function is an optimization for <a>selectionModelGetSelection</a>
--   when you are only interested in part of the model's selected state. A
--   common use case is in response to the
--   <a>SelectionModel::selectionChanged</a> signal.
selectionModelGetSelectionInRange :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Word32 -> Word32 -> m Bitset

-- | Checks if the given item is selected.
selectionModelIsSelected :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Word32 -> m Bool

-- | Requests to select all items in the model.
selectionModelSelectAll :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> m Bool

-- | Requests to select an item in the model.
selectionModelSelectItem :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Word32 -> Bool -> m Bool

-- | Requests to select a range of items in the model.
selectionModelSelectRange :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Word32 -> Word32 -> Bool -> m Bool

-- | Helper function for implementations of <tt>GtkSelectionModel</tt>.
--   
--   Call this when the selection changes to emit the
--   <a>SelectionModel::selectionChanged</a> signal.
selectionModelSelectionChanged :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Word32 -> Word32 -> m ()

-- | Make selection changes.
--   
--   This is the most advanced selection updating method that allows the
--   most fine-grained control over selection changes. If you can, you
--   should try the simpler versions, as implementations are more likely to
--   implement support for those.
--   
--   Requests that the selection state of all positions set in
--   <i><tt>mask</tt></i> be updated to the respective value in the
--   <i><tt>selected</tt></i> bitmask.
--   
--   In pseudocode, it would look something like this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   for (i = 0; i &lt; n_items; i++)
--     {
--       // don't change values not in the mask
--       if (!gtk_bitset_contains (mask, i))
--         continue;
--   
--       if (gtk_bitset_contains (selected, i))
--         select_item (i);
--       else
--         unselect_item (i);
--     }
--   
--   gtk_selection_model_selection_changed (model,
--                                          first_changed_item,
--                                          n_changed_items);
--   </pre>
--   
--   <i><tt>mask</tt></i> and <i><tt>selected</tt></i> must not be
--   modified. They may refer to the same bitset, which would mean that
--   every item in the set should be selected.
selectionModelSetSelection :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Bitset -> Bitset -> m Bool

-- | Requests to unselect all items in the model.
selectionModelUnselectAll :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> m Bool

-- | Requests to unselect an item in the model.
selectionModelUnselectItem :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Word32 -> m Bool

-- | Requests to unselect a range of items in the model.
selectionModelUnselectRange :: (HasCallStack, MonadIO m, IsSelectionModel a) => a -> Word32 -> Word32 -> m Bool

-- | Emitted when the selection state of some of the items in
--   <i><tt>model</tt></i> changes.
--   
--   Note that this signal does not specify the new selection state of the
--   items, they need to be queried manually. It is also not necessary for
--   a model to change the selection state of any of the items in the
--   selection model, though it would be rather useless to emit such a
--   signal.
type SelectionModelSelectionChangedCallback = Word32 -> Word32 -> IO ()

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> selectionModel #selectionChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSelectionModelSelectionChanged :: (IsSelectionModel a, MonadIO m) => a -> ((?self :: a) => SelectionModelSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> selectionModel #selectionChanged callback
--   </pre>
onSelectionModelSelectionChanged :: (IsSelectionModel a, MonadIO m) => a -> ((?self :: a) => SelectionModelSelectionChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.SelectionModel.SelectionModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.SelectionModel.SelectionModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.SelectionModel.SelectionModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.SelectionModel.SelectionModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.SelectionModel.SelectionModel o) => GI.Gtk.Interfaces.SelectionModel.IsSelectionModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.SelectionModel.SelectionModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.SelectionModel.SelectionModel


-- | Iterates over the elements of a <a>Bitset</a>.
--   
--   @GtkBitSetIter is an opaque, stack-allocated struct.
--   
--   Before a @GtkBitsetIter` can be used, it needs to be initialized with
--   <a>bitsetIterInitFirst</a>, <a>bitsetIterInitLast</a> or
--   <a>bitsetIterInitAt</a>.
module GI.Gtk.Structs.BitsetIter

-- | Memory-managed wrapper type.
newtype BitsetIter
BitsetIter :: ManagedPtr BitsetIter -> BitsetIter

-- | Construct a <a>BitsetIter</a> struct initialized to zero.
newZeroBitsetIter :: MonadIO m => m BitsetIter

-- | Gets the current value that <i><tt>iter</tt></i> points to.
--   
--   If <i><tt>iter</tt></i> is not valid and <a>bitsetIterIsValid</a>
--   returns <a>False</a>, this function returns 0.
bitsetIterGetValue :: (HasCallStack, MonadIO m) => BitsetIter -> m Word32

-- | Initializes <i><tt>iter</tt></i> to point to <i><tt>target</tt></i>.
--   
--   If <i><tt>target</tt></i> is not found, finds the next value after it.
--   If no value &gt;= <i><tt>target</tt></i> exists in
--   <i><tt>set</tt></i>, this function returns <a>False</a>.
bitsetIterInitAt :: (HasCallStack, MonadIO m) => Bitset -> Word32 -> m (Bool, BitsetIter, Word32)

-- | Initializes an iterator for <i><tt>set</tt></i> and points it to the
--   first value in <i><tt>set</tt></i>.
--   
--   If <i><tt>set</tt></i> is empty, <a>False</a> is returned and
--   <i><tt>value</tt></i> is set to <tt><i>G_MAXUINT</i></tt>.
bitsetIterInitFirst :: (HasCallStack, MonadIO m) => Bitset -> m (Bool, BitsetIter, Word32)

-- | Initializes an iterator for <i><tt>set</tt></i> and points it to the
--   last value in <i><tt>set</tt></i>.
--   
--   If <i><tt>set</tt></i> is empty, <a>False</a> is returned.
bitsetIterInitLast :: (HasCallStack, MonadIO m) => Bitset -> m (Bool, BitsetIter, Word32)

-- | Checks if <i><tt>iter</tt></i> points to a valid value.
bitsetIterIsValid :: (HasCallStack, MonadIO m) => BitsetIter -> m Bool

-- | Moves <i><tt>iter</tt></i> to the next value in the set.
--   
--   If it was already pointing to the last value in the set, <a>False</a>
--   is returned and <i><tt>iter</tt></i> is invalidated.
bitsetIterNext :: (HasCallStack, MonadIO m) => BitsetIter -> m (Bool, Word32)

-- | Moves <i><tt>iter</tt></i> to the previous value in the set.
--   
--   If it was already pointing to the first value in the set, <a>False</a>
--   is returned and <i><tt>iter</tt></i> is invalidated.
bitsetIterPrevious :: (HasCallStack, MonadIO m) => BitsetIter -> m (Bool, Word32)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BitsetIter.BitsetIter tag
instance GHC.Classes.Eq GI.Gtk.Structs.BitsetIter.BitsetIter
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.BitsetIter.BitsetIter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.BitsetIter.BitsetIter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.BitsetIter.BitsetIter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.BitsetIter.BitsetIter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.BitsetIter.BitsetIter


-- | Specifies a border around a rectangular area.
--   
--   Each side can have a different width.
module GI.Gtk.Structs.Border

-- | Memory-managed wrapper type.
newtype Border
Border :: ManagedPtr Border -> Border

-- | Construct a <a>Border</a> struct initialized to zero.
newZeroBorder :: MonadIO m => m Border

-- | Copies a <tt>GtkBorder</tt>.
borderCopy :: (HasCallStack, MonadIO m) => Border -> m Border

-- | Frees a <tt>GtkBorder</tt>.
borderFree :: (HasCallStack, MonadIO m) => Border -> m ()

-- | Allocates a new <tt>GtkBorder</tt> struct and initializes its elements
--   to zero.
borderNew :: (HasCallStack, MonadIO m) => m Border

-- | Get the value of the “<tt>bottom</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #bottom
--   </pre>
getBorderBottom :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>bottom</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #bottom <a>:=</a> value ]
--   </pre>
setBorderBottom :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “<tt>left</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #left
--   </pre>
getBorderLeft :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>left</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #left <a>:=</a> value ]
--   </pre>
setBorderLeft :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “<tt>right</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #right
--   </pre>
getBorderRight :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>right</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #right <a>:=</a> value ]
--   </pre>
setBorderRight :: MonadIO m => Border -> Int16 -> m ()

-- | Get the value of the “<tt>top</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> border #top
--   </pre>
getBorderTop :: MonadIO m => Border -> m Int16

-- | Set the value of the “<tt>top</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> border [ #top <a>:=</a> value ]
--   </pre>
setBorderTop :: MonadIO m => Border -> Int16 -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.Border.Border tag
instance GHC.Classes.Eq GI.Gtk.Structs.Border.Border
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.Border.Border
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.Border.Border
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.Border.Border)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.Border.Border
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.Border.Border


-- | <tt>GtkStyleContext</tt> stores styling information affecting a
--   widget.
--   
--   In order to construct the final style information,
--   <tt>GtkStyleContext</tt> queries information from all attached
--   <tt>GtkStyleProviders</tt>. Style providers can be either attached
--   explicitly to the context through <a>styleContextAddProvider</a>, or
--   to the display through <a>styleContextAddProviderForDisplay</a>. The
--   resulting style is a combination of all providers’ information in
--   priority order.
--   
--   For GTK widgets, any <tt>GtkStyleContext</tt> returned by
--   <a>widgetGetStyleContext</a> will already have a <tt>GdkDisplay</tt>
--   and RTL/LTR information set. The style context will also be updated
--   automatically if any of these settings change on the widget.
--   
--   <h2>Style Classes</h2>
--   
--   Widgets can add style classes to their context, which can be used to
--   associate different styles by class. The documentation for individual
--   widgets lists which style classes it uses itself, and which style
--   classes may be added by applications to affect their appearance.
--   
--   <h1>Custom styling in UI libraries and applications</h1>
--   
--   If you are developing a library with custom widgets that render
--   differently than standard components, you may need to add a
--   <tt>GtkStyleProvider</tt> yourself with the
--   <a>STYLE_PROVIDER_PRIORITY_FALLBACK</a> priority, either a
--   <tt>GtkCssProvider</tt> or a custom object implementing the
--   <tt>GtkStyleProvider</tt> interface. This way themes may still attempt
--   to style your UI elements in a different way if needed so.
--   
--   If you are using custom styling on an applications, you probably want
--   then to make your style information prevail to the theme’s, so you
--   must use a <tt>GtkStyleProvider</tt> with the
--   <a>STYLE_PROVIDER_PRIORITY_APPLICATION</a> priority, keep in mind that
--   the user settings in <tt>XDG_CONFIG_HOME/gtk-4.0/gtk.css</tt> will
--   still take precedence over your changes, as it uses the
--   <a>STYLE_PROVIDER_PRIORITY_USER</a> priority.
module GI.Gtk.Objects.StyleContext

-- | Memory-managed wrapper type.
newtype StyleContext
StyleContext :: ManagedPtr StyleContext -> StyleContext

-- | Type class for types which can be safely cast to <a>StyleContext</a>,
--   for instance with <a>toStyleContext</a>.
class (GObject o, IsDescendantOf StyleContext o) => IsStyleContext o

-- | Cast to <a>StyleContext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStyleContext :: (MonadIO m, IsStyleContext o) => o -> m StyleContext

-- | Adds a style class to <i><tt>context</tt></i>, so later uses of the
--   style context will make use of this new class for styling.
--   
--   In the CSS file format, a <tt>GtkEntry</tt> defining a “search” class,
--   would be matched by:
--   
--   <h3><i>css code</i></h3>
--   
--   <pre>
--   entry.search { ... }
--   </pre>
--   
--   While any widget defining a “search” class would be matched by:
--   
--   <h3><i>css code</i></h3>
--   
--   <pre>
--   .search { ... }
--   </pre>

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetAddCssClass</a>
--   instead</i>
styleContextAddClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | Adds a style provider to <i><tt>context</tt></i>, to be used in style
--   construction.
--   
--   Note that a style provider added by this function only affects the
--   style of the widget to which <i><tt>context</tt></i> belongs. If you
--   want to affect the style of all widgets, use
--   <a>styleContextAddProviderForDisplay</a>.
--   
--   Note: If both priorities are the same, a <tt>GtkStyleProvider</tt>
--   added through this function takes precedence over another added
--   through <a>styleContextAddProviderForDisplay</a>.

-- | <i>Deprecated: (Since version 4.10)Use style classes instead</i>
styleContextAddProvider :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleProvider b) => a -> b -> Word32 -> m ()

-- | Adds a global style provider to <i><tt>display</tt></i>, which will be
--   used in style construction for all <tt>GtkStyleContexts</tt> under
--   <i><tt>display</tt></i>.
--   
--   GTK uses this to make styling information from <tt>GtkSettings</tt>
--   available.
--   
--   Note: If both priorities are the same, A <tt>GtkStyleProvider</tt>
--   added through <a>styleContextAddProvider</a> takes precedence over
--   another added through this function.
styleContextAddProviderForDisplay :: (HasCallStack, MonadIO m, IsDisplay a, IsStyleProvider b) => a -> b -> Word32 -> m ()

-- | Gets the border for a given state as a <tt>GtkBorder</tt>.

-- | <i>Deprecated: (Since version 4.10)This api will be removed in GTK
--   5</i>
styleContextGetBorder :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Border

-- | Gets the foreground color for a given state.

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetGetColor</a>
--   instead</i>
styleContextGetColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m RGBA

-- | Returns the <tt>GdkDisplay</tt> to which <i><tt>context</tt></i> is
--   attached.

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetGetDisplay</a>
--   instead</i>
styleContextGetDisplay :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Display

-- | Gets the margin for a given state as a <tt>GtkBorder</tt>.

-- | <i>Deprecated: (Since version 4.10)This api will be removed in GTK
--   5</i>
styleContextGetMargin :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Border

-- | Gets the padding for a given state as a <tt>GtkBorder</tt>.

-- | <i>Deprecated: (Since version 4.10)This api will be removed in GTK
--   5</i>
styleContextGetPadding :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Border

-- | Returns the scale used for assets.

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetGetScaleFactor</a>
--   instead</i>
styleContextGetScale :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m Int32

-- | Returns the state used for style matching.
--   
--   This method should only be used to retrieve the <tt>GtkStateFlags</tt>
--   to pass to <tt>GtkStyleContext</tt> methods, like
--   <a>styleContextGetPadding</a>. If you need to retrieve the current
--   state of a <tt>GtkWidget</tt>, use <a>widgetGetStateFlags</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetGetStateFlags</a>
--   instead</i>
styleContextGetState :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m [StateFlags]

-- | Returns <a>True</a> if <i><tt>context</tt></i> currently has defined
--   the given class name.

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetHasCssClass</a>
--   instead</i>
styleContextHasClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m Bool

-- | Looks up and resolves a color name in the <i><tt>context</tt></i>
--   color map.

-- | <i>Deprecated: (Since version 4.10)This api will be removed in GTK
--   5</i>
styleContextLookupColor :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m (Bool, RGBA)

-- | Removes <i><tt>className</tt></i> from <i><tt>context</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetRemoveCssClass</a>
--   instead</i>
styleContextRemoveClass :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Text -> m ()

-- | Removes <i><tt>provider</tt></i> from the style providers list in
--   <i><tt>context</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
styleContextRemoveProvider :: (HasCallStack, MonadIO m, IsStyleContext a, IsStyleProvider b) => a -> b -> m ()

-- | Removes <i><tt>provider</tt></i> from the global style providers list
--   in <i><tt>display</tt></i>.
styleContextRemoveProviderForDisplay :: (HasCallStack, MonadIO m, IsDisplay a, IsStyleProvider b) => a -> b -> m ()

-- | Restores <i><tt>context</tt></i> state to a previous stage.
--   
--   See <a>styleContextSave</a>.

-- | <i>Deprecated: (Since version 4.10)This API will be removed in GTK
--   5</i>
styleContextRestore :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Saves the <i><tt>context</tt></i> state.
--   
--   This allows temporary modifications done through
--   <a>styleContextAddClass</a>, <a>styleContextRemoveClass</a>,
--   <a>styleContextSetState</a> to be quickly reverted in one go through
--   <a>styleContextRestore</a>.
--   
--   The matching call to <a>styleContextRestore</a> must be done before
--   GTK returns to the main loop.

-- | <i>Deprecated: (Since version 4.10)This API will be removed in GTK
--   5</i>
styleContextSave :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> m ()

-- | Attaches <i><tt>context</tt></i> to the given display.
--   
--   The display is used to add style information from “global” style
--   providers, such as the display's <tt>GtkSettings</tt> instance.
--   
--   If you are using a <tt>GtkStyleContext</tt> returned from
--   <a>widgetGetStyleContext</a>, you do not need to call this yourself.

-- | <i>Deprecated: (Since version 4.10)You should not use this api</i>
styleContextSetDisplay :: (HasCallStack, MonadIO m, IsStyleContext a, IsDisplay b) => a -> b -> m ()

-- | Sets the scale to use when getting image assets for the style.

-- | <i>Deprecated: (Since version 4.10)You should not use this api</i>
styleContextSetScale :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Int32 -> m ()

-- | Sets the state to be used for style matching.

-- | <i>Deprecated: (Since version 4.10)You should not use this api</i>
styleContextSetState :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StateFlags] -> m ()

-- | Converts the style context into a string representation.
--   
--   The string representation always includes information about the name,
--   state, id, visibility and style classes of the CSS node that is
--   backing <i><tt>context</tt></i>. Depending on the flags, more
--   information may be included.
--   
--   This function is intended for testing and debugging of the CSS
--   implementation in GTK. There are no guarantees about the format of the
--   returned string, it may change.

-- | <i>Deprecated: (Since version 4.10)This api will be removed in GTK
--   5</i>
styleContextToString :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> [StyleContextPrintFlags] -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>display</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStyleContextDisplay :: (IsStyleContext o, MonadIO m, IsDisplay a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> styleContext #display
--   </pre>
getStyleContextDisplay :: (MonadIO m, IsStyleContext o) => o -> m Display

-- | Set the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> styleContext [ #display <a>:=</a> value ]
--   </pre>
setStyleContextDisplay :: (MonadIO m, IsStyleContext o, IsDisplay a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.StyleContext.StyleContext
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StyleContext.StyleContext
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StyleContext.StyleContext
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StyleContext.StyleContext)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StyleContext.StyleContext o) => GI.Gtk.Objects.StyleContext.IsStyleContext o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StyleContext.StyleContext
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StyleContext.StyleContext


-- | Assists in creating <a>RenderNode</a>s for widgets.
--   
--   It functions in a similar way to a cairo context, and maintains a
--   stack of render nodes and their associated transformations.
--   
--   The node at the top of the stack is the one that
--   <tt>gtk_snapshot_append_…()</tt> functions operate on. Use the
--   <tt>gtk_snapshot_push_…()</tt> functions and
--   [method<i><tt>snapshot</tt></i>.pop] to change the current node.
--   
--   The typical way to obtain a <tt>GtkSnapshot</tt> object is as an
--   argument to the <a>Widget</a>.<tt><i>snapshot</i></tt>() vfunc. If you
--   need to create your own <tt>GtkSnapshot</tt>, use <a>snapshotNew</a>.
--   
--   Note that <tt>GtkSnapshot</tt> applies some optimizations, so the node
--   it produces may not match the API calls 1:1. For example, it will omit
--   clip nodes if the child node is entirely contained within the clip
--   rectangle.
module GI.Gtk.Objects.Snapshot

-- | Memory-managed wrapper type.
newtype Snapshot
Snapshot :: ManagedPtr Snapshot -> Snapshot

-- | Type class for types which can be safely cast to <a>Snapshot</a>, for
--   instance with <a>toSnapshot</a>.
class (GObject o, IsDescendantOf Snapshot o) => IsSnapshot o

-- | Cast to <a>Snapshot</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSnapshot :: (MonadIO m, IsSnapshot o) => o -> m Snapshot

-- | Appends a stroked border rectangle inside the given
--   <i><tt>outline</tt></i>.
--   
--   The four sides of the border can have different widths and colors.
snapshotAppendBorder :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> RoundedRect -> [Float] -> [RGBA] -> m ()

-- | Creates a new <a>CairoNode</a> and appends it to the current render
--   node of <i><tt>snapshot</tt></i>, without changing the current node.
snapshotAppendCairo :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> m Context

-- | Creates a new render node drawing the <i><tt>color</tt></i> into the
--   given <i><tt>bounds</tt></i> and appends it to the current render node
--   of <i><tt>snapshot</tt></i>.
--   
--   You should try to avoid calling this function if <i><tt>color</tt></i>
--   is transparent.
snapshotAppendColor :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> RGBA -> Rect -> m ()

-- | Appends a conic gradient node with the given stops to
--   <i><tt>snapshot</tt></i>.
snapshotAppendConicGradient :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> Point -> Float -> [ColorStop] -> m ()

-- | A convenience method to fill a path with a color.
--   
--   See <a>snapshotPushFill</a> if you need to fill a path with more
--   complex content than a color.
--   
--   <i>Since: 4.14</i>
snapshotAppendFill :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Path -> FillRule -> RGBA -> m ()

-- | Appends an inset shadow into the box given by <i><tt>outline</tt></i>.
snapshotAppendInsetShadow :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> RoundedRect -> RGBA -> Float -> Float -> Float -> Float -> m ()

-- | Creates render nodes for rendering <i><tt>layout</tt></i> in the given
--   foregound <i><tt>color</tt></i> and appends them to the current node
--   of <i><tt>snapshot</tt></i> without changing the current node. The
--   current theme's foreground color for a widget can be obtained with
--   <a>widgetGetColor</a>.
--   
--   Note that if the layout does not produce any visible output, then
--   nodes may not be added to the <i><tt>snapshot</tt></i>.
snapshotAppendLayout :: (HasCallStack, MonadIO m, IsSnapshot a, IsLayout b) => a -> b -> RGBA -> m ()

-- | Appends a linear gradient node with the given stops to
--   <i><tt>snapshot</tt></i>.
snapshotAppendLinearGradient :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> Point -> Point -> [ColorStop] -> m ()

-- | Appends <i><tt>node</tt></i> to the current render node of
--   <i><tt>snapshot</tt></i>, without changing the current node.
--   
--   If <i><tt>snapshot</tt></i> does not have a current node yet,
--   <i><tt>node</tt></i> will become the initial node.
snapshotAppendNode :: (HasCallStack, MonadIO m, IsSnapshot a, IsRenderNode b) => a -> b -> m ()

-- | Appends an outset shadow node around the box given by
--   <i><tt>outline</tt></i>.
snapshotAppendOutsetShadow :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> RoundedRect -> RGBA -> Float -> Float -> Float -> Float -> m ()

-- | Creates a new render node that pastes the contents copied by a
--   previous call to <a>snapshotPushCopy</a>
--   
--   <i>Since: 4.22</i>
snapshotAppendPaste :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> CSize -> m ()

-- | Appends a radial gradient node with the given stops to
--   <i><tt>snapshot</tt></i>.
snapshotAppendRadialGradient :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> Point -> Float -> Float -> Float -> Float -> [ColorStop] -> m ()

-- | Appends a repeating linear gradient node with the given stops to
--   <i><tt>snapshot</tt></i>.
snapshotAppendRepeatingLinearGradient :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> Point -> Point -> [ColorStop] -> m ()

-- | Appends a repeating radial gradient node with the given stops to
--   <i><tt>snapshot</tt></i>.
snapshotAppendRepeatingRadialGradient :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> Point -> Float -> Float -> Float -> Float -> [ColorStop] -> m ()

-- | Creates a new render node drawing the <i><tt>texture</tt></i> into the
--   given <i><tt>bounds</tt></i> and appends it to the current render node
--   of <i><tt>snapshot</tt></i>.
--   
--   In contrast to <a>snapshotAppendTexture</a>, this function provides
--   control about how the filter that is used when scaling.
--   
--   <i>Since: 4.10</i>
snapshotAppendScaledTexture :: (HasCallStack, MonadIO m, IsSnapshot a, IsTexture b) => a -> b -> ScalingFilter -> Rect -> m ()

-- | A convenience method to stroke a path with a color.
--   
--   See <a>snapshotPushStroke</a> if you need to stroke a path with more
--   complex content than a color.
--   
--   <i>Since: 4.14</i>
snapshotAppendStroke :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Path -> Stroke -> RGBA -> m ()

-- | Creates a new render node drawing the <i><tt>texture</tt></i> into the
--   given <i><tt>bounds</tt></i> and appends it to the current render node
--   of <i><tt>snapshot</tt></i>.
--   
--   If the texture needs to be scaled to fill <i><tt>bounds</tt></i>,
--   linear filtering is used. See <a>snapshotAppendScaledTexture</a> if
--   you need other filtering, such as nearest-neighbour.
snapshotAppendTexture :: (HasCallStack, MonadIO m, IsSnapshot a, IsTexture b) => a -> b -> Rect -> m ()

-- | Removes the top element from the stack of render nodes and adds it to
--   the nearest <a>GLShaderNode</a> below it.
--   
--   This must be called the same number of times as the number of textures
--   is needed for the shader in <a>snapshotPushGlShader</a>.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GLArea</a> forOpenGL
--   rendering.</i>
snapshotGlShaderPopTexture :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> m ()

-- | Creates a new <tt>GtkSnapshot</tt>.
snapshotNew :: (HasCallStack, MonadIO m) => m Snapshot

-- | Applies a perspective projection transform.
--   
--   See <a>transformPerspective</a> for a discussion on the details.
snapshotPerspective :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Float -> m ()

-- | Removes the top element from the stack of render nodes, and appends it
--   to the node underneath it.
snapshotPop :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> m ()

-- | Blends together two images with the given blend mode.
--   
--   Until the first call to <a>snapshotPop</a>, the bottom image for the
--   blend operation will be recorded. After that call, the top image to be
--   blended will be recorded until the second call to <a>snapshotPop</a>.
--   
--   Calling this function requires two subsequent calls to
--   <a>snapshotPop</a>.
snapshotPushBlend :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> BlendMode -> m ()

-- | Blurs an image.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
snapshotPushBlur :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Double -> m ()

-- | Clips an image to a rectangle.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
snapshotPushClip :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> m ()

-- | Modifies the colors of an image by applying an affine transformation
--   in RGB space.
--   
--   In particular, the colors will be transformed by applying
--   
--   pixel = transpose(color_matrix) * pixel + color_offset
--   
--   for every pixel. The transformation operates on unpremultiplied
--   colors, with color components ordered R, G, B, A.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
snapshotPushColorMatrix :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Matrix -> Vec4 -> m ()

-- | Modifies the colors of an image by applying a transfer function for
--   each component.
--   
--   The transfer functions operate on unpremultiplied colors.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
--   
--   <i>Since: 4.20</i>
snapshotPushComponentTransfer :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> ComponentTransfer -> ComponentTransfer -> ComponentTransfer -> ComponentTransfer -> m ()

-- | Until the first call to <a>snapshotPop</a>, the mask image for the
--   mask operation will be recorded.
--   
--   After that call, the child image will be recorded until the second
--   call to <a>snapshotPop</a>.
--   
--   Calling this function requires 2 subsequent calls to
--   <a>snapshotPop</a>.
--   
--   <i>Since: 4.22</i>
snapshotPushComposite :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> PorterDuff -> m ()

-- | Stores the current rendering state for later pasting via
--   <a>snapshotAppendPaste</a>.
--   
--   Pasting is possible until the matching call to <a>snapshotPop</a>.
--   
--   <i>Since: 4.22</i>
snapshotPushCopy :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> m ()

-- | Snapshots a cross-fade operation between two images with the given
--   <i><tt>progress</tt></i>.
--   
--   Until the first call to <a>snapshotPop</a>, the start image will be
--   snapshot. After that call, the end image will be recorded until the
--   second call to <a>snapshotPop</a>.
--   
--   Calling this function requires two subsequent calls to
--   <a>snapshotPop</a>.
snapshotPushCrossFade :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Double -> m ()

-- | Fills the area given by <i><tt>path</tt></i> and
--   <i><tt>fillRule</tt></i> with an image and discards everything outside
--   of it.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
--   
--   If you want to fill the path with a color, <a>snapshotAppendFill</a>
--   than rendering new ones, use <a>snapshotAppendFill</a> may be more
--   convenient.
--   
--   <i>Since: 4.14</i>
snapshotPushFill :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Path -> FillRule -> m ()

-- | Push a <a>GLShaderNode</a>.
--   
--   The node uses the given <a>GLShader</a> and uniform values
--   Additionally this takes a list of <i><tt>nChildren</tt></i> other
--   nodes which will be passed to the <a>GLShaderNode</a>.
--   
--   The <i><tt>takeArgs</tt></i> argument is a block of data to use for
--   uniform arguments, as per types and offsets defined by the
--   <i><tt>shader</tt></i>. Normally this is generated by
--   <a>GLShader</a>.<tt><i>format_args</i></tt>() or
--   <a>ShaderArgsBuilder</a>.
--   
--   The snapshotter takes ownership of <i><tt>takeArgs</tt></i>, so the
--   caller should not free it after this.
--   
--   If the renderer doesn't support GL shaders, or if there is any problem
--   when compiling the shader, then the node will draw pink. You should
--   use <a>gLShaderCompile</a> to ensure the <i><tt>shader</tt></i> will
--   work for the renderer before using it.
--   
--   If the shader requires textures (see <a>gLShaderGetNTextures</a>),
--   then it is expected that you call <a>snapshotGlShaderPopTexture</a>
--   the number of times that are required. Each of these calls will
--   generate a node that is added as a child to the
--   <tt>GskGLShaderNode</tt>, which in turn will render these offscreen
--   and pass as a texture to the shader.
--   
--   Once all textures (if any) are pop:ed, you must call the regular
--   <a>snapshotPop</a>.
--   
--   If you want to use pre-existing textures as input to the shader rather
--   than rendering new ones, use <a>snapshotAppendTexture</a> to push a
--   texture node. These will be used directly rather than being
--   re-rendered.
--   
--   For details on how to write shaders, see <a>GLShader</a>.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GLArea</a> forOpenGL
--   rendering.</i>
snapshotPushGlShader :: (HasCallStack, MonadIO m, IsSnapshot a, IsGLShader b) => a -> b -> Rect -> Bytes -> m ()

-- | Isolates the following drawing operations from previous ones.
--   
--   You can express "everything but these flags" in a forward compatible
--   way by using bit math: <tt>GSK_ISOLATION_ALL &amp;
--   ~(GSK_ISOLATION_BACKGROUND | GSK_ISOLATION_COPY_PASTE)</tt> will
--   isolate everything but background and copy/paste.
--   
--   For what isolation features exist, see
--   [flags<i><tt>gsk</tt></i>.Isolation].
--   
--   Content is isolated until the next call to <a>snapshotPop</a>.
--   
--   <i>Since: 4.22</i>
snapshotPushIsolation :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> [Isolation] -> m ()

-- | Until the first call to <a>snapshotPop</a>, the mask image for the
--   mask operation will be recorded.
--   
--   After that call, the source image will be recorded until the second
--   call to <a>snapshotPop</a>.
--   
--   Calling this function requires 2 subsequent calls to
--   <a>snapshotPop</a>.
--   
--   <i>Since: 4.10</i>
snapshotPushMask :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> MaskMode -> m ()

-- | Modifies the opacity of an image.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
snapshotPushOpacity :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Double -> m ()

-- | Creates a node that repeats the child node.
--   
--   The child is recorded until the next call to <a>snapshotPop</a>.
snapshotPushRepeat :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Rect -> Maybe Rect -> m ()

-- | Clips an image to a rounded rectangle.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
snapshotPushRoundedClip :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> RoundedRect -> m ()

-- | Applies a shadow to an image.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
snapshotPushShadow :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> [Shadow] -> m ()

-- | Strokes the given <i><tt>path</tt></i> with the attributes given by
--   <i><tt>stroke</tt></i> and an image.
--   
--   The image is recorded until the next call to <a>snapshotPop</a>.
--   
--   Note that the strokes are subject to the same transformation as
--   everything else, so uneven scaling will cause horizontal and vertical
--   strokes to have different widths.
--   
--   If you want to stroke the path with a color,
--   <a>snapshotAppendStroke</a> may be more convenient.
--   
--   <i>Since: 4.14</i>
snapshotPushStroke :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Path -> Stroke -> m ()

-- | Creates a render node for the CSS background according to
--   <i><tt>context</tt></i>, and appends it to the current node of
--   <i><tt>snapshot</tt></i>, without changing the current node.

-- | <i>Deprecated: (Since version 4.10)</i>
snapshotRenderBackground :: (HasCallStack, MonadIO m, IsSnapshot a, IsStyleContext b) => a -> b -> Double -> Double -> Double -> Double -> m ()

-- | Creates a render node for the focus outline according to
--   <i><tt>context</tt></i>, and appends it to the current node of
--   <i><tt>snapshot</tt></i>, without changing the current node.

-- | <i>Deprecated: (Since version 4.10)</i>
snapshotRenderFocus :: (HasCallStack, MonadIO m, IsSnapshot a, IsStyleContext b) => a -> b -> Double -> Double -> Double -> Double -> m ()

-- | Creates a render node for the CSS border according to
--   <i><tt>context</tt></i>, and appends it to the current node of
--   <i><tt>snapshot</tt></i>, without changing the current node.

-- | <i>Deprecated: (Since version 4.10)</i>
snapshotRenderFrame :: (HasCallStack, MonadIO m, IsSnapshot a, IsStyleContext b) => a -> b -> Double -> Double -> Double -> Double -> m ()

-- | Draws a text caret using <i><tt>snapshot</tt></i> at the specified
--   index of <i><tt>layout</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
snapshotRenderInsertionCursor :: (HasCallStack, MonadIO m, IsSnapshot a, IsStyleContext b, IsLayout c) => a -> b -> Double -> Double -> c -> Int32 -> Direction -> m ()

-- | Creates a render node for rendering <i><tt>layout</tt></i> according
--   to the style information in <i><tt>context</tt></i>, and appends it to
--   the current node of <i><tt>snapshot</tt></i>, without changing the
--   current node.

-- | <i>Deprecated: (Since version 4.10)</i>
snapshotRenderLayout :: (HasCallStack, MonadIO m, IsSnapshot a, IsStyleContext b, IsLayout c) => a -> b -> Double -> Double -> c -> m ()

-- | Restores <i><tt>snapshot</tt></i> to the state saved by a preceding
--   call to [method<i><tt>snapshot</tt></i>.save] and removes that state
--   from the stack of saved states.
snapshotRestore :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> m ()

-- | Rotates @<i><tt>snapshot</tt></i>'s coordinate system by
--   <i><tt>angle</tt></i> degrees in 2D space - or in 3D speak, rotates
--   around the Z axis. The rotation happens around the origin point of (0,
--   0) in the <i><tt>snapshot</tt></i>'s current coordinate system.
--   
--   To rotate around axes other than the Z axis, use
--   <a>transformRotate3d</a>.
snapshotRotate :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Float -> m ()

-- | Rotates <i><tt>snapshot</tt></i>'s coordinate system by
--   <i><tt>angle</tt></i> degrees around <i><tt>axis</tt></i>.
--   
--   For a rotation in 2D space, use <a>transformRotate</a>.
snapshotRotate3d :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Float -> Vec3 -> m ()

-- | Makes a copy of the current state of <i><tt>snapshot</tt></i> and
--   saves it on an internal stack.
--   
--   When <a>snapshotRestore</a> is called, <i><tt>snapshot</tt></i> will
--   be restored to the saved state.
--   
--   Multiple calls to <a>snapshotSave</a> and <a>snapshotRestore</a> can
--   be nested; each call to <tt>gtk_snapshot_restore()</tt> restores the
--   state from the matching paired <tt>gtk_snapshot_save()</tt>.
--   
--   It is necessary to clear all saved states with corresponding calls to
--   <tt>gtk_snapshot_restore()</tt>.
snapshotSave :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> m ()

-- | Scales <i><tt>snapshot</tt></i>'s coordinate system in 2-dimensional
--   space by the given factors.
--   
--   Use <a>snapshotScale3d</a> to scale in all 3 dimensions.
snapshotScale :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Float -> Float -> m ()

-- | Scales <i><tt>snapshot</tt></i>'s coordinate system by the given
--   factors.
snapshotScale3d :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Float -> Float -> Float -> m ()

-- | Returns the render node that was constructed by
--   <i><tt>snapshot</tt></i>.
--   
--   Note that this function may return <a>Nothing</a> if nothing has been
--   added to the snapshot or if its content does not produce pixels to be
--   rendered.
--   
--   After calling this function, it is no longer possible to add more
--   nodes to <i><tt>snapshot</tt></i>. The only function that should be
--   called after this is <a>objectUnref</a>.
snapshotToNode :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> m (Maybe RenderNode)

-- | Returns a paintable encapsulating the render node that was constructed
--   by <i><tt>snapshot</tt></i>.
--   
--   After calling this function, it is no longer possible to add more
--   nodes to <i><tt>snapshot</tt></i>. The only function that should be
--   called after this is <a>objectUnref</a>.
snapshotToPaintable :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Maybe Size -> m (Maybe Paintable)

-- | Transforms <i><tt>snapshot</tt></i>'s coordinate system with the given
--   <i><tt>transform</tt></i>.
snapshotTransform :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Maybe Transform -> m ()

-- | Transforms <i><tt>snapshot</tt></i>'s coordinate system with the given
--   <i><tt>matrix</tt></i>.
snapshotTransformMatrix :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Matrix -> m ()

-- | Translates <i><tt>snapshot</tt></i>'s coordinate system by
--   <i><tt>point</tt></i> in 2-dimensional space.
snapshotTranslate :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Point -> m ()

-- | Translates <i><tt>snapshot</tt></i>'s coordinate system by
--   <i><tt>point</tt></i>.
snapshotTranslate3d :: (HasCallStack, MonadIO m, IsSnapshot a) => a -> Point3D -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Snapshot.Snapshot
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Snapshot.Snapshot
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Snapshot.Snapshot
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Snapshot.Snapshot)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Snapshot.Snapshot o) => GI.Gtk.Objects.Snapshot.IsSnapshot o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Snapshot.Snapshot
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Snapshot.Snapshot


-- | An interface for widgets with native scrolling ability.
--   
--   To implement this interface you should override the
--   <a>Scrollable:hadjustment</a> and <a>Scrollable:vadjustment</a>
--   properties.
--   
--   <h2>Creating a scrollable widget</h2>
--   
--   All scrollable widgets should do the following.
--   
--   <ul>
--   <li>When a parent widget sets the scrollable child widget’s
--   adjustments, the widget should connect to the
--   <a>Adjustment::valueChanged</a> signal. The child widget should then
--   populate the adjustments’ properties as soon as possible, which
--   usually means queueing an allocation right away and populating the
--   properties in the <a>Widget</a>.<tt><i>size_allocate</i></tt>()
--   implementation.</li>
--   <li>Because its preferred size is the size for a fully expanded
--   widget, the scrollable widget must be able to cope with
--   underallocations. This means that it must accept any value passed to
--   its <a>Widget</a>.<tt><i>size_allocate</i></tt>() implementation.</li>
--   <li>When the parent allocates space to the scrollable child widget,
--   the widget must ensure the adjustments’ property values are correct
--   and up to date, for example using <a>adjustmentConfigure</a>.</li>
--   <li>When any of the adjustments emits the
--   <a>Adjustment::valueChanged</a> signal, the scrollable widget should
--   scroll its contents.</li>
--   </ul>
module GI.Gtk.Interfaces.Scrollable

-- | Memory-managed wrapper type.
newtype Scrollable
Scrollable :: ManagedPtr Scrollable -> Scrollable

-- | Type class for types which can be safely cast to <a>Scrollable</a>,
--   for instance with <a>toScrollable</a>.
class (GObject o, IsDescendantOf Scrollable o) => IsScrollable o

-- | Cast to <a>Scrollable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScrollable :: (MonadIO m, IsScrollable o) => o -> m Scrollable

-- | Returns the size of a non-scrolling border around the outside of the
--   scrollable.
--   
--   An example for this would be treeview headers. GTK can use this
--   information to display overlaid graphics, like the overshoot
--   indication, at the right position.
scrollableGetBorder :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m (Bool, Border)

-- | Retrieves the <tt>GtkAdjustment</tt> used for horizontal scrolling.
scrollableGetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m (Maybe Adjustment)

-- | Gets the horizontal <tt>GtkScrollablePolicy</tt>.
scrollableGetHscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m ScrollablePolicy

-- | Retrieves the <tt>GtkAdjustment</tt> used for vertical scrolling.
scrollableGetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m (Maybe Adjustment)

-- | Gets the vertical <tt>GtkScrollablePolicy</tt>.
scrollableGetVscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> m ScrollablePolicy

-- | Sets the horizontal adjustment of the <tt>GtkScrollable</tt>.
scrollableSetHadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkScrollablePolicy</tt>.
--   
--   The policy determines whether horizontal scrolling should start below
--   the minimum width or below the natural width.
scrollableSetHscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> ScrollablePolicy -> m ()

-- | Sets the vertical adjustment of the <tt>GtkScrollable</tt>.
scrollableSetVadjustment :: (HasCallStack, MonadIO m, IsScrollable a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkScrollablePolicy</tt>.
--   
--   The policy determines whether vertical scrolling should start below
--   the minimum height or below the natural height.
scrollableSetVscrollPolicy :: (HasCallStack, MonadIO m, IsScrollable a) => a -> ScrollablePolicy -> m ()

-- | Set the value of the “<tt>hadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #hadjustment
--   </pre>
clearScrollableHadjustment :: (MonadIO m, IsScrollable o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrollableHadjustment :: (IsScrollable o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #hadjustment
--   </pre>
getScrollableHadjustment :: (MonadIO m, IsScrollable o) => o -> m (Maybe Adjustment)

-- | Set the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #hadjustment <a>:=</a> value ]
--   </pre>
setScrollableHadjustment :: (MonadIO m, IsScrollable o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hscroll-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrollableHscrollPolicy :: (IsScrollable o, MonadIO m) => ScrollablePolicy -> m (GValueConstruct o)

-- | Get the value of the “<tt>hscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #hscrollPolicy
--   </pre>
getScrollableHscrollPolicy :: (MonadIO m, IsScrollable o) => o -> m ScrollablePolicy

-- | Set the value of the “<tt>hscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #hscrollPolicy <a>:=</a> value ]
--   </pre>
setScrollableHscrollPolicy :: (MonadIO m, IsScrollable o) => o -> ScrollablePolicy -> m ()

-- | Set the value of the “<tt>vadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #vadjustment
--   </pre>
clearScrollableVadjustment :: (MonadIO m, IsScrollable o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrollableVadjustment :: (IsScrollable o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #vadjustment
--   </pre>
getScrollableVadjustment :: (MonadIO m, IsScrollable o) => o -> m (Maybe Adjustment)

-- | Set the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #vadjustment <a>:=</a> value ]
--   </pre>
setScrollableVadjustment :: (MonadIO m, IsScrollable o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vscroll-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrollableVscrollPolicy :: (IsScrollable o, MonadIO m) => ScrollablePolicy -> m (GValueConstruct o)

-- | Get the value of the “<tt>vscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollable #vscrollPolicy
--   </pre>
getScrollableVscrollPolicy :: (MonadIO m, IsScrollable o) => o -> m ScrollablePolicy

-- | Set the value of the “<tt>vscroll-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollable [ #vscrollPolicy <a>:=</a> value ]
--   </pre>
setScrollableVscrollPolicy :: (MonadIO m, IsScrollable o) => o -> ScrollablePolicy -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.Scrollable.Scrollable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Scrollable.Scrollable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Scrollable.Scrollable
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Scrollable.Scrollable)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Scrollable.Scrollable o) => GI.Gtk.Interfaces.Scrollable.IsScrollable o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Scrollable.Scrollable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Scrollable.Scrollable


-- | Points at a location inside a CSS stream.
module GI.Gtk.Structs.CssLocation

-- | Memory-managed wrapper type.
newtype CssLocation
CssLocation :: ManagedPtr CssLocation -> CssLocation

-- | Construct a <a>CssLocation</a> struct initialized to zero.
newZeroCssLocation :: MonadIO m => m CssLocation

-- | Get the value of the “<tt>bytes</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssLocation #bytes
--   </pre>
getCssLocationBytes :: MonadIO m => CssLocation -> m CSize

-- | Set the value of the “<tt>bytes</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssLocation [ #bytes <a>:=</a> value ]
--   </pre>
setCssLocationBytes :: MonadIO m => CssLocation -> CSize -> m ()

-- | Get the value of the “<tt>chars</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssLocation #chars
--   </pre>
getCssLocationChars :: MonadIO m => CssLocation -> m CSize

-- | Set the value of the “<tt>chars</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssLocation [ #chars <a>:=</a> value ]
--   </pre>
setCssLocationChars :: MonadIO m => CssLocation -> CSize -> m ()

-- | Get the value of the “<tt>line_bytes</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssLocation #lineBytes
--   </pre>
getCssLocationLineBytes :: MonadIO m => CssLocation -> m CSize

-- | Set the value of the “<tt>line_bytes</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssLocation [ #lineBytes <a>:=</a> value ]
--   </pre>
setCssLocationLineBytes :: MonadIO m => CssLocation -> CSize -> m ()

-- | Get the value of the “<tt>line_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssLocation #lineChars
--   </pre>
getCssLocationLineChars :: MonadIO m => CssLocation -> m CSize

-- | Set the value of the “<tt>line_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssLocation [ #lineChars <a>:=</a> value ]
--   </pre>
setCssLocationLineChars :: MonadIO m => CssLocation -> CSize -> m ()

-- | Get the value of the “<tt>lines</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssLocation #lines
--   </pre>
getCssLocationLines :: MonadIO m => CssLocation -> m CSize

-- | Set the value of the “<tt>lines</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssLocation [ #lines <a>:=</a> value ]
--   </pre>
setCssLocationLines :: MonadIO m => CssLocation -> CSize -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.CssLocation.CssLocation
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.CssLocation.CssLocation
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.CssLocation.CssLocation tag
instance GHC.Classes.Eq GI.Gtk.Structs.CssLocation.CssLocation
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.CssLocation.CssLocation


-- | Defines a part of a CSS document.
--   
--   Because sections are nested into one another, you can use
--   [method<i><tt>cssSection</tt></i>.get_parent] to get the containing
--   region.
module GI.Gtk.Structs.CssSection

-- | Memory-managed wrapper type.
newtype CssSection
CssSection :: ManagedPtr CssSection -> CssSection

-- | Gets the bytes that <i><tt>section</tt></i> was parsed from.
--   
--   <i>Since: 4.16</i>
cssSectionGetBytes :: (HasCallStack, MonadIO m) => CssSection -> m (Maybe Bytes)

-- | Returns the location in the CSS document where this section ends.
cssSectionGetEndLocation :: (HasCallStack, MonadIO m) => CssSection -> m CssLocation

-- | Gets the file that <i><tt>section</tt></i> was parsed from.
--   
--   If no such file exists, for example because the CSS was loaded via
--   <a>cssProviderLoadFromData</a>, then <tt>NULL</tt> is returned.
cssSectionGetFile :: (HasCallStack, MonadIO m) => CssSection -> m (Maybe File)

-- | Gets the parent section for the given <tt>section</tt>.
--   
--   The parent section is the section that contains this <tt>section</tt>.
--   A special case are sections of type <tt>GTK_CSS_SECTION_DOCUMENT</tt>.
--   Their parent will either be <tt>NULL</tt> if they are the original CSS
--   document that was loaded by <a>cssProviderLoadFromFile</a> or a
--   section of type <tt>GTK_CSS_SECTION_IMPORT</tt> if it was loaded with
--   an <tt>@import</tt> rule from a different file.
cssSectionGetParent :: (HasCallStack, MonadIO m) => CssSection -> m (Maybe CssSection)

-- | Returns the location in the CSS document where this section starts.
cssSectionGetStartLocation :: (HasCallStack, MonadIO m) => CssSection -> m CssLocation

-- | Creates a new <tt>GtkCssSection</tt> referring to the section in the
--   given <tt>file</tt> from the <tt>start</tt> location to the
--   <tt>end</tt> location.
cssSectionNew :: (HasCallStack, MonadIO m, IsFile a) => Maybe a -> CssLocation -> CssLocation -> m CssSection

-- | Creates a new <tt>GtkCssSection</tt> referring to the section in the
--   given <tt>file</tt> or the given <tt>bytes</tt> from the
--   <tt>start</tt> location to the <tt>end</tt> location.
--   
--   <i>Since: 4.16</i>
cssSectionNewWithBytes :: (HasCallStack, MonadIO m, IsFile a) => Maybe a -> Maybe Bytes -> CssLocation -> CssLocation -> m CssSection

-- | Prints the <tt>section</tt> into <tt>string</tt> in a human-readable
--   form.
--   
--   This is a form like <tt>gtk.css:32:1-23</tt> to denote line 32,
--   characters 1 to 23 in the file <tt>gtk.css</tt>.
cssSectionPrint :: (HasCallStack, MonadIO m) => CssSection -> String -> m ()

-- | Increments the reference count on <tt>section</tt>.
cssSectionRef :: (HasCallStack, MonadIO m) => CssSection -> m CssSection

-- | Prints the section into a human-readable text form using
--   <a>cssSectionPrint</a>.
cssSectionToString :: (HasCallStack, MonadIO m) => CssSection -> m Text

-- | Decrements the reference count on <tt>section</tt>, freeing the
--   structure if the reference count reaches 0.
cssSectionUnref :: (HasCallStack, MonadIO m) => CssSection -> m ()
instance GHC.Classes.Eq GI.Gtk.Structs.CssSection.CssSection
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.CssSection.CssSection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.CssSection.CssSection
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.CssSection.CssSection)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.CssSection.CssSection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.CssSection.CssSection


-- | A style provider for CSS.
--   
--   It is able to parse CSS-like input in order to style widgets.
--   
--   An application can make GTK parse a specific CSS style sheet by
--   calling <a>cssProviderLoadFromFile</a> or
--   <a>cssProviderLoadFromResource</a> and adding the provider with
--   <a>styleContextAddProvider</a> or
--   <a>styleContextAddProviderForDisplay</a>.
--   
--   In addition, certain files will be read when GTK is initialized.
--   First, the file <tt>$XDG_CONFIG_HOME/gtk-4.0/gtk.css</tt> is loaded if
--   it exists. Then, GTK loads the first existing file among
--   <tt>XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk-VARIANT.css</tt>,
--   <tt>$HOME/.themes/THEME/gtk-VERSION/gtk-VARIANT.css</tt>,
--   <tt>$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk-VARIANT.css</tt> and
--   <tt>DATADIR/share/themes/THEME/gtk-VERSION/gtk-VARIANT.css</tt>, where
--   <tt>THEME</tt> is the name of the current theme (see the
--   <a>Settings:gtkThemeName</a> setting), <tt>VARIANT</tt> is the variant
--   to load (see the <a>Settings:gtkApplicationPreferDarkTheme</a>
--   setting), <tt>DATADIR</tt> is the prefix configured when GTK was
--   compiled (unless overridden by the <tt>GTK_DATA_PREFIX</tt>
--   environment variable), and <tt>VERSION</tt> is the GTK version number.
--   If no file is found for the current version, GTK tries older versions
--   all the way back to 4.0.
--   
--   To track errors while loading CSS, connect to the
--   <a>CssProvider::parsingError</a> signal.
module GI.Gtk.Objects.CssProvider

-- | Memory-managed wrapper type.
newtype CssProvider
CssProvider :: ManagedPtr CssProvider -> CssProvider

-- | Type class for types which can be safely cast to <a>CssProvider</a>,
--   for instance with <a>toCssProvider</a>.
class (GObject o, IsDescendantOf CssProvider o) => IsCssProvider o

-- | Cast to <a>CssProvider</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCssProvider :: (MonadIO m, IsCssProvider o) => o -> m CssProvider

-- | Loads <i><tt>data</tt></i> into <i><tt>cssProvider</tt></i>.
--   
--   This clears any previously loaded information.
--   
--   <i>Since: 4.12</i>
cssProviderLoadFromBytes :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Bytes -> m ()

-- | Loads <i><tt>data</tt></i> into <i><tt>cssProvider</tt></i>.
--   
--   This clears any previously loaded information.

-- | <i>Deprecated: (Since version 4.12)Use
--   <a>cssProviderLoadFromString</a>or <a>cssProviderLoadFromBytes</a>
--   instead</i>
cssProviderLoadFromData :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> Int64 -> m ()

-- | Loads the data contained in <i><tt>file</tt></i> into
--   <i><tt>cssProvider</tt></i>.
--   
--   This clears any previously loaded information.
cssProviderLoadFromFile :: (HasCallStack, MonadIO m, IsCssProvider a, IsFile b) => a -> b -> m ()

-- | Loads the data contained in <i><tt>path</tt></i> into
--   <i><tt>cssProvider</tt></i>.
--   
--   This clears any previously loaded information.
cssProviderLoadFromPath :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> [Char] -> m ()

-- | Loads the data contained in the resource at
--   <i><tt>resourcePath</tt></i> into the <i><tt>cssProvider</tt></i>.
--   
--   This clears any previously loaded information.
cssProviderLoadFromResource :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> m ()

-- | Loads <i><tt>string</tt></i> into <i><tt>cssProvider</tt></i>.
--   
--   This clears any previously loaded information.
--   
--   <i>Since: 4.12</i>
cssProviderLoadFromString :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> m ()

-- | Loads a theme from the usual theme paths.
--   
--   The actual process of finding the theme might change between releases,
--   but it is guaranteed that this function uses the same mechanism to
--   load the theme that GTK uses for loading its own theme.

-- | <i>Deprecated: (Since version 4.20)Using any of the other theme
--   loaders, combine with media queries.</i>
cssProviderLoadNamed :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> Text -> Maybe Text -> m ()

-- | Returns a newly created <tt>GtkCssProvider</tt>.
cssProviderNew :: (HasCallStack, MonadIO m) => m CssProvider

-- | Converts the <i><tt>provider</tt></i> into a string representation in
--   CSS format.
--   
--   Using <a>cssProviderLoadFromString</a> with the return value from this
--   function on a new provider created with <a>cssProviderNew</a> will
--   basically create a duplicate of this <i><tt>provider</tt></i>.
cssProviderToString :: (HasCallStack, MonadIO m, IsCssProvider a) => a -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>prefers-color-scheme</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCssProviderPrefersColorScheme :: (IsCssProvider o, MonadIO m) => InterfaceColorScheme -> m (GValueConstruct o)

-- | Get the value of the “<tt>prefers-color-scheme</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssProvider #prefersColorScheme
--   </pre>
getCssProviderPrefersColorScheme :: (MonadIO m, IsCssProvider o) => o -> m InterfaceColorScheme

-- | Set the value of the “<tt>prefers-color-scheme</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssProvider [ #prefersColorScheme <a>:=</a> value ]
--   </pre>
setCssProviderPrefersColorScheme :: (MonadIO m, IsCssProvider o) => o -> InterfaceColorScheme -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>prefers-contrast</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCssProviderPrefersContrast :: (IsCssProvider o, MonadIO m) => InterfaceContrast -> m (GValueConstruct o)

-- | Get the value of the “<tt>prefers-contrast</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssProvider #prefersContrast
--   </pre>
getCssProviderPrefersContrast :: (MonadIO m, IsCssProvider o) => o -> m InterfaceContrast

-- | Set the value of the “<tt>prefers-contrast</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssProvider [ #prefersContrast <a>:=</a> value ]
--   </pre>
setCssProviderPrefersContrast :: (MonadIO m, IsCssProvider o) => o -> InterfaceContrast -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>prefers-reduced-motion</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCssProviderPrefersReducedMotion :: (IsCssProvider o, MonadIO m) => ReducedMotion -> m (GValueConstruct o)

-- | Get the value of the “<tt>prefers-reduced-motion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cssProvider #prefersReducedMotion
--   </pre>
getCssProviderPrefersReducedMotion :: (MonadIO m, IsCssProvider o) => o -> m ReducedMotion

-- | Set the value of the “<tt>prefers-reduced-motion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cssProvider [ #prefersReducedMotion <a>:=</a> value ]
--   </pre>
setCssProviderPrefersReducedMotion :: (MonadIO m, IsCssProvider o) => o -> ReducedMotion -> m ()

-- | Signals that a parsing error occurred.
--   
--   The expected error values are in the
--   [error<i><tt>gtk</tt></i>.CssParserError] and <a>CssParserWarning</a>
--   enumerations.
--   
--   The <i><tt>path</tt></i>, <i><tt>line</tt></i> and
--   <i><tt>position</tt></i> describe the actual location of the error as
--   accurately as possible.
--   
--   Parsing errors are never fatal, so the parsing will resume after the
--   error. Errors may however cause parts of the given data or even all of
--   it to not be parsed at all. So it is a useful idea to check that the
--   parsing succeeds by connecting to this signal.
--   
--   Errors in the <a>CssParserWarning</a> enumeration should not be
--   treated as fatal errors.
--   
--   Note that this signal may be emitted at any time as the css provider
--   may opt to defer parsing parts or all of the input to a later time
--   than when a loading function was called.
type CssProviderParsingErrorCallback = CssSection -> GError -> IO ()

-- | Connect a signal handler for the <a>parsingError</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cssProvider #parsingError callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCssProviderParsingError :: (IsCssProvider a, MonadIO m) => a -> ((?self :: a) => CssProviderParsingErrorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>parsingError</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cssProvider #parsingError callback
--   </pre>
onCssProviderParsingError :: (IsCssProvider a, MonadIO m) => a -> ((?self :: a) => CssProviderParsingErrorCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CssProvider.CssProvider
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CssProvider.CssProvider
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CssProvider.CssProvider
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CssProvider.CssProvider o) => GI.Gtk.Objects.CssProvider.IsCssProvider o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CssProvider.CssProvider)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CssProvider.CssProvider
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CssProvider.CssProvider


-- | A CSS style change.
module GI.Gtk.Structs.CssStyleChange

-- | Memory-managed wrapper type.
newtype CssStyleChange
CssStyleChange :: ManagedPtr CssStyleChange -> CssStyleChange
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.CssStyleChange.CssStyleChange
instance GHC.Classes.Eq GI.Gtk.Structs.CssStyleChange.CssStyleChange
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.CssStyleChange.CssStyleChange


-- | An opaque structure representing a watched <tt>GtkExpression</tt>.
--   
--   The contents of <tt>GtkExpressionWatch</tt> should only be accessed
--   through the provided API.
module GI.Gtk.Structs.ExpressionWatch

-- | Memory-managed wrapper type.
newtype ExpressionWatch
ExpressionWatch :: ManagedPtr ExpressionWatch -> ExpressionWatch

-- | Evaluates the watched expression and on success stores the result in
--   <tt>value</tt>.
--   
--   This is equivalent to calling <a>expressionEvaluate</a> with the
--   expression and this pointer originally used to create <tt>watch</tt>.
expressionWatchEvaluate :: (HasCallStack, MonadIO m) => ExpressionWatch -> GValue -> m Bool

-- | Acquires a reference on the given <tt>GtkExpressionWatch</tt>.
expressionWatchRef :: (HasCallStack, MonadIO m) => ExpressionWatch -> m ExpressionWatch

-- | Releases a reference on the given <tt>GtkExpressionWatch</tt>.
--   
--   If the reference was the last, the resources associated to
--   <tt>self</tt> are freed.
expressionWatchUnref :: (HasCallStack, MonadIO m) => ExpressionWatch -> m ()

-- | Stops watching an expression.
--   
--   See <a>expressionWatch</a> for how the watch was established.
expressionWatchUnwatch :: (HasCallStack, MonadIO m) => ExpressionWatch -> m ()
instance GHC.Classes.Eq GI.Gtk.Structs.ExpressionWatch.ExpressionWatch
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.ExpressionWatch.ExpressionWatch
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.ExpressionWatch.ExpressionWatch
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.ExpressionWatch.ExpressionWatch)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.ExpressionWatch.ExpressionWatch
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.ExpressionWatch.ExpressionWatch


-- | Struct defining a pad action entry.
module GI.Gtk.Structs.PadActionEntry

-- | Memory-managed wrapper type.
newtype PadActionEntry
PadActionEntry :: ManagedPtr PadActionEntry -> PadActionEntry

-- | Construct a <a>PadActionEntry</a> struct initialized to zero.
newZeroPadActionEntry :: MonadIO m => m PadActionEntry

-- | Set the value of the “<tt>action_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #actionName
--   </pre>
clearPadActionEntryActionName :: MonadIO m => PadActionEntry -> m ()

-- | Get the value of the “<tt>action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #actionName
--   </pre>
getPadActionEntryActionName :: MonadIO m => PadActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>action_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #actionName <a>:=</a> value ]
--   </pre>
setPadActionEntryActionName :: MonadIO m => PadActionEntry -> CString -> m ()

-- | Get the value of the “<tt>index</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #index
--   </pre>
getPadActionEntryIndex :: MonadIO m => PadActionEntry -> m Int32

-- | Set the value of the “<tt>index</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #index <a>:=</a> value ]
--   </pre>
setPadActionEntryIndex :: MonadIO m => PadActionEntry -> Int32 -> m ()

-- | Set the value of the “<tt>label</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearPadActionEntryLabel :: MonadIO m => PadActionEntry -> m ()

-- | Get the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #label
--   </pre>
getPadActionEntryLabel :: MonadIO m => PadActionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #label <a>:=</a> value ]
--   </pre>
setPadActionEntryLabel :: MonadIO m => PadActionEntry -> CString -> m ()

-- | Get the value of the “<tt>mode</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #mode
--   </pre>
getPadActionEntryMode :: MonadIO m => PadActionEntry -> m Int32

-- | Set the value of the “<tt>mode</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #mode <a>:=</a> value ]
--   </pre>
setPadActionEntryMode :: MonadIO m => PadActionEntry -> Int32 -> m ()

-- | Get the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padActionEntry #type
--   </pre>
getPadActionEntryType :: MonadIO m => PadActionEntry -> m PadActionType

-- | Set the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> padActionEntry [ #type <a>:=</a> value ]
--   </pre>
setPadActionEntryType :: MonadIO m => PadActionEntry -> PadActionType -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.PadActionEntry.PadActionEntry
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.PadActionEntry.PadActionEntry
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.PadActionEntry.PadActionEntry tag
instance GHC.Classes.Eq GI.Gtk.Structs.PadActionEntry.PadActionEntry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.PadActionEntry.PadActionEntry


-- | A range of pages to print.
--   
--   See also <a>printSettingsSetPageRanges</a>.
module GI.Gtk.Structs.PageRange

-- | Memory-managed wrapper type.
newtype PageRange
PageRange :: ManagedPtr PageRange -> PageRange

-- | Construct a <a>PageRange</a> struct initialized to zero.
newZeroPageRange :: MonadIO m => m PageRange

-- | Get the value of the “<tt>end</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pageRange #end
--   </pre>
getPageRangeEnd :: MonadIO m => PageRange -> m Int32

-- | Set the value of the “<tt>end</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pageRange [ #end <a>:=</a> value ]
--   </pre>
setPageRangeEnd :: MonadIO m => PageRange -> Int32 -> m ()

-- | Get the value of the “<tt>start</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pageRange #start
--   </pre>
getPageRangeStart :: MonadIO m => PageRange -> m Int32

-- | Set the value of the “<tt>start</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pageRange [ #start <a>:=</a> value ]
--   </pre>
setPageRangeStart :: MonadIO m => PageRange -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.PageRange.PageRange
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.PageRange.PageRange
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.PageRange.PageRange tag
instance GHC.Classes.Eq GI.Gtk.Structs.PageRange.PageRange
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.PageRange.PageRange


-- | <tt>GtkPaperSize</tt> handles paper sizes.
--   
--   It uses the standard called <a>PWG 5101.1-2002 PWG: Standard for Media
--   Standardized Names</a> to name the paper sizes (and to get the data
--   for the page sizes). In addition to standard paper sizes,
--   <tt>GtkPaperSize</tt> allows to construct custom paper sizes with
--   arbitrary dimensions.
--   
--   The <tt>GtkPaperSize</tt> object stores not only the dimensions (width
--   and height) of a paper size and its name, it also provides default
--   print margins.
module GI.Gtk.Structs.PaperSize

-- | Memory-managed wrapper type.
newtype PaperSize
PaperSize :: ManagedPtr PaperSize -> PaperSize

-- | Copies an existing <tt>GtkPaperSize</tt>.
paperSizeCopy :: (HasCallStack, MonadIO m) => PaperSize -> m PaperSize

-- | Free the given <tt>GtkPaperSize</tt> object.
paperSizeFree :: (HasCallStack, MonadIO m) => PaperSize -> m ()

-- | Returns the name of the default paper size, which depends on the
--   current locale.
paperSizeGetDefault :: (HasCallStack, MonadIO m) => m Text

-- | Gets the default bottom margin for the <tt>GtkPaperSize</tt>.
paperSizeGetDefaultBottomMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default left margin for the <tt>GtkPaperSize</tt>.
paperSizeGetDefaultLeftMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default right margin for the <tt>GtkPaperSize</tt>.
paperSizeGetDefaultRightMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the default top margin for the <tt>GtkPaperSize</tt>.
paperSizeGetDefaultTopMargin :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the human-readable name of the <tt>GtkPaperSize</tt>.
paperSizeGetDisplayName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the paper height of the <tt>GtkPaperSize</tt>, in units of
--   <i><tt>unit</tt></i>.
paperSizeGetHeight :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Gets the name of the <tt>GtkPaperSize</tt>.
paperSizeGetName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Creates a list of known paper sizes.
paperSizeGetPaperSizes :: (HasCallStack, MonadIO m) => Bool -> m [PaperSize]

-- | Gets the PPD name of the <tt>GtkPaperSize</tt>, which may be
--   <a>Nothing</a>.
paperSizeGetPpdName :: (HasCallStack, MonadIO m) => PaperSize -> m Text

-- | Gets the paper width of the <tt>GtkPaperSize</tt>, in units of
--   <i><tt>unit</tt></i>.
paperSizeGetWidth :: (HasCallStack, MonadIO m) => PaperSize -> Unit -> m Double

-- | Returns <a>True</a> if <i><tt>size</tt></i> is not a standard paper
--   size.
paperSizeIsCustom :: (HasCallStack, MonadIO m) => PaperSize -> m Bool

-- | Compares two <tt>GtkPaperSize</tt> objects.
paperSizeIsEqual :: (HasCallStack, MonadIO m) => PaperSize -> PaperSize -> m Bool

-- | Returns <a>True</a> if <i><tt>size</tt></i> is an IPP standard paper
--   size.
paperSizeIsIpp :: (HasCallStack, MonadIO m) => PaperSize -> m Bool

-- | Creates a new <tt>GtkPaperSize</tt> object by parsing a <a>PWG
--   5101.1-2002</a> paper name.
--   
--   If <i><tt>name</tt></i> is <a>Nothing</a>, the default paper size is
--   returned, see <a>paperSizeGetDefault</a>.
paperSizeNew :: (HasCallStack, MonadIO m) => Maybe Text -> m PaperSize

-- | Creates a new <tt>GtkPaperSize</tt> object with the given parameters.
paperSizeNewCustom :: (HasCallStack, MonadIO m) => Text -> Text -> Double -> Double -> Unit -> m PaperSize

-- | Deserialize a paper size from a <tt>GVariant</tt>.
--   
--   The `GVariant must be in the format produced by
--   <a>paperSizeToGvariant</a>.
paperSizeNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PaperSize

-- | Creates a new <tt>GtkPaperSize</tt> object by using IPP information.
--   
--   If <i><tt>ippName</tt></i> is not a recognized paper name,
--   <i><tt>width</tt></i> and <i><tt>height</tt></i> are used to construct
--   a custom <tt>GtkPaperSize</tt> object.
paperSizeNewFromIpp :: (HasCallStack, MonadIO m) => Text -> Double -> Double -> m PaperSize

-- | Reads a paper size from the group <i><tt>groupName</tt></i> in the key
--   file <i><tt>keyFile</tt></i>.
paperSizeNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PaperSize

-- | Creates a new <tt>GtkPaperSize</tt> object by using PPD information.
--   
--   If <i><tt>ppdName</tt></i> is not a recognized PPD paper name,
--   <i><tt>ppdDisplayName</tt></i>, <i><tt>width</tt></i> and
--   <i><tt>height</tt></i> are used to construct a custom
--   <tt>GtkPaperSize</tt> object.
paperSizeNewFromPpd :: (HasCallStack, MonadIO m) => Text -> Text -> Double -> Double -> m PaperSize

-- | Changes the dimensions of a <i><tt>size</tt></i> to
--   <i><tt>width</tt></i> x <i><tt>height</tt></i>.
paperSizeSetSize :: (HasCallStack, MonadIO m) => PaperSize -> Double -> Double -> Unit -> m ()

-- | Serialize a paper size to an <tt>a{sv}</tt> variant.
paperSizeToGvariant :: (HasCallStack, MonadIO m) => PaperSize -> m GVariant

-- | This function adds the paper size from <i><tt>size</tt></i> to
--   <i><tt>keyFile</tt></i>.
paperSizeToKeyFile :: (HasCallStack, MonadIO m) => PaperSize -> KeyFile -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Structs.PaperSize.PaperSize
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.PaperSize.PaperSize
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.PaperSize.PaperSize
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.PaperSize.PaperSize)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.PaperSize.PaperSize
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.PaperSize.PaperSize


-- | Encapsulates context information that is required when drawing pages
--   for printing.
--   
--   This includes the cairo context and important parameters like page
--   size and resolution. It also lets you easily create <a>Layout</a> and
--   <a>Context</a> objects that match the font metrics of the cairo
--   surface.
--   
--   <tt>GtkPrintContext</tt> objects get passed to the
--   <a>PrintOperation::beginPrint</a>, <a>PrintOperation::endPrint</a>,
--   <a>PrintOperation::requestPageSetup</a> and
--   <a>PrintOperation::drawPage</a> signals on the <a>PrintOperation</a>
--   object.
--   
--   <h2>Using GtkPrintContext in a <a>drawPage</a> callback</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   draw_page (GtkPrintOperation *operation,
--              GtkPrintContext   *context,
--              int                page_nr)
--   {
--     cairo_t *cr;
--     PangoLayout *layout;
--     PangoFontDescription *desc;
--   
--     cr = gtk_print_context_get_cairo_context (context);
--   
--     // Draw a red rectangle, as wide as the paper (inside the margins)
--     cairo_set_source_rgb (cr, 1.0, 0, 0);
--     cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50);
--   
--     cairo_fill (cr);
--   
--     // Draw some lines
--     cairo_move_to (cr, 20, 10);
--     cairo_line_to (cr, 40, 20);
--     cairo_arc (cr, 60, 60, 20, 0, M_PI);
--     cairo_line_to (cr, 80, 20);
--   
--     cairo_set_source_rgb (cr, 0, 0, 0);
--     cairo_set_line_width (cr, 5);
--     cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
--     cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
--   
--     cairo_stroke (cr);
--   
--     // Draw some text
--     layout = gtk_print_context_create_pango_layout (context);
--     pango_layout_set_text (layout, "Hello World! Printing is easy", -1);
--     desc = pango_font_description_from_string ("sans 28");
--     pango_layout_set_font_description (layout, desc);
--     pango_font_description_free (desc);
--   
--     cairo_move_to (cr, 30, 20);
--     pango_cairo_layout_path (cr, layout);
--   
--     // Font Outline
--     cairo_set_source_rgb (cr, 0.93, 1.0, 0.47);
--     cairo_set_line_width (cr, 0.5);
--     cairo_stroke_preserve (cr);
--   
--     // Font Fill
--     cairo_set_source_rgb (cr, 0, 0.0, 1.0);
--     cairo_fill (cr);
--   
--     g_object_unref (layout);
--   }
--   </pre>
module GI.Gtk.Objects.PrintContext

-- | Memory-managed wrapper type.
newtype PrintContext
PrintContext :: ManagedPtr PrintContext -> PrintContext

-- | Type class for types which can be safely cast to <a>PrintContext</a>,
--   for instance with <a>toPrintContext</a>.
class (GObject o, IsDescendantOf PrintContext o) => IsPrintContext o

-- | Cast to <a>PrintContext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPrintContext :: (MonadIO m, IsPrintContext o) => o -> m PrintContext

-- | Creates a new <tt>PangoContext</tt> that can be used with the
--   <tt>GtkPrintContext</tt>.
printContextCreatePangoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Context

-- | Creates a new <tt>PangoLayout</tt> that is suitable for use with the
--   <tt>GtkPrintContext</tt>.
printContextCreatePangoLayout :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Layout

-- | Obtains the cairo context that is associated with the
--   <tt>GtkPrintContext</tt>.
printContextGetCairoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Context

-- | Obtains the horizontal resolution of the <tt>GtkPrintContext</tt>, in
--   dots per inch.
printContextGetDpiX :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the vertical resolution of the <tt>GtkPrintContext</tt>, in
--   dots per inch.
printContextGetDpiY :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the hardware printer margins of the <tt>GtkPrintContext</tt>,
--   in units.
printContextGetHardMargins :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m (Bool, Double, Double, Double, Double)

-- | Obtains the height of the <tt>GtkPrintContext</tt>, in pixels.
printContextGetHeight :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Obtains the <tt>GtkPageSetup</tt> that determines the page dimensions
--   of the <tt>GtkPrintContext</tt>.
printContextGetPageSetup :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m PageSetup

-- | Returns a <tt>PangoFontMap</tt> that is suitable for use with the
--   <tt>GtkPrintContext</tt>.
printContextGetPangoFontmap :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m FontMap

-- | Obtains the width of the <tt>GtkPrintContext</tt>, in pixels.
printContextGetWidth :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> m Double

-- | Sets a new cairo context on a print context.
--   
--   This function is intended to be used when implementing an internal
--   print preview, it is not needed for printing, since GTK itself creates
--   a suitable cairo context in that case.
printContextSetCairoContext :: (HasCallStack, MonadIO m, IsPrintContext a) => a -> Context -> Double -> Double -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PrintContext.PrintContext
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PrintContext.PrintContext
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PrintContext.PrintContext
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PrintContext.PrintContext)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PrintContext.PrintContext o) => GI.Gtk.Objects.PrintContext.IsPrintContext o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PrintContext.PrintContext
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PrintContext.PrintContext


-- | Stores page size, orientation and margins for printing.
--   
--   The idea is that you can get one of these from the page setup dialog
--   and then pass it to the <tt>GtkPrintOperation</tt> when printing. The
--   benefit of splitting this out of the <tt>GtkPrintSettings</tt> is that
--   these affect the actual layout of the page, and thus need to be set
--   long before user prints.
--   
--   <h2>Margins</h2>
--   
--   The margins specified in this object are the “print margins”, i.e. the
--   parts of the page that the printer cannot print on. These are
--   different from the layout margins that a word processor uses; they are
--   typically used to determine the minimal size for the layout margins.
--   
--   To obtain a <tt>GtkPageSetup</tt> use <a>pageSetupNew</a> to get the
--   defaults, or use <a>printRunPageSetupDialog</a> to show the page setup
--   dialog and receive the resulting page setup.
--   
--   <h2>A page setup dialog</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static GtkPrintSettings *settings = NULL;
--   static GtkPageSetup *page_setup = NULL;
--   
--   static void
--   do_page_setup (void)
--   {
--     GtkPageSetup *new_page_setup;
--   
--     if (settings == NULL)
--       settings = gtk_print_settings_new ();
--   
--     new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
--                                                       page_setup, settings);
--   
--     if (page_setup)
--       g_object_unref (page_setup);
--   
--     page_setup = new_page_setup;
--   }
--   </pre>
module GI.Gtk.Objects.PageSetup

-- | Memory-managed wrapper type.
newtype PageSetup
PageSetup :: ManagedPtr PageSetup -> PageSetup

-- | Type class for types which can be safely cast to <a>PageSetup</a>, for
--   instance with <a>toPageSetup</a>.
class (GObject o, IsDescendantOf PageSetup o) => IsPageSetup o

-- | Cast to <a>PageSetup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPageSetup :: (MonadIO m, IsPageSetup o) => o -> m PageSetup

-- | Copies a <tt>GtkPageSetup</tt>.
pageSetupCopy :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PageSetup

-- | Gets the bottom margin in units of <i><tt>unit</tt></i>.
pageSetupGetBottomMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the left margin in units of <i><tt>unit</tt></i>.
pageSetupGetLeftMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the page orientation of the <tt>GtkPageSetup</tt>.
pageSetupGetOrientation :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PageOrientation

-- | Returns the page height in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation and margins into
--   consideration. See <a>pageSetupGetPaperHeight</a>.
pageSetupGetPageHeight :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Returns the page width in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation and margins into
--   consideration. See <a>pageSetupGetPaperWidth</a>.
pageSetupGetPageWidth :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Returns the paper height in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation, but not margins into
--   consideration. See <a>pageSetupGetPageHeight</a>.
pageSetupGetPaperHeight :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the paper size of the <tt>GtkPageSetup</tt>.
pageSetupGetPaperSize :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m PaperSize

-- | Returns the paper width in units of <i><tt>unit</tt></i>.
--   
--   Note that this function takes orientation, but not margins into
--   consideration. See <a>pageSetupGetPageWidth</a>.
pageSetupGetPaperWidth :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the right margin in units of <i><tt>unit</tt></i>.
pageSetupGetRightMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Gets the top margin in units of <i><tt>unit</tt></i>.
pageSetupGetTopMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Unit -> m Double

-- | Reads the page setup from the file <i><tt>fileName</tt></i>.
--   
--   See <a>pageSetupToFile</a>.
pageSetupLoadFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> [Char] -> m ()

-- | Reads the page setup from the group <i><tt>groupName</tt></i> in the
--   key file <i><tt>keyFile</tt></i>.
pageSetupLoadKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe Text -> m ()

-- | Creates a new <tt>GtkPageSetup</tt>.
pageSetupNew :: (HasCallStack, MonadIO m) => m PageSetup

-- | Reads the page setup from the file <i><tt>fileName</tt></i>.
--   
--   Returns a new <tt>GtkPageSetup</tt> object with the restored page
--   setup, or <a>Nothing</a> if an error occurred. See
--   <a>pageSetupToFile</a>.
pageSetupNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m PageSetup

-- | Desrialize a page setup from an a{sv} variant.
--   
--   The variant must be in the format produced by
--   <a>pageSetupToGvariant</a>.
pageSetupNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PageSetup

-- | Reads the page setup from the group <i><tt>groupName</tt></i> in the
--   key file <i><tt>keyFile</tt></i>.
--   
--   Returns a new <tt>GtkPageSetup</tt> object with the restored page
--   setup, or <a>Nothing</a> if an error occurred.
pageSetupNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PageSetup

-- | Sets the bottom margin of the <tt>GtkPageSetup</tt>.
pageSetupSetBottomMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the left margin of the <tt>GtkPageSetup</tt>.
pageSetupSetLeftMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the page orientation of the <tt>GtkPageSetup</tt>.
pageSetupSetOrientation :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PageOrientation -> m ()

-- | Sets the paper size of the <tt>GtkPageSetup</tt> without changing the
--   margins.
--   
--   See <a>pageSetupSetPaperSizeAndDefaultMargins</a>.
pageSetupSetPaperSize :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PaperSize -> m ()

-- | Sets the paper size of the <tt>GtkPageSetup</tt> and modifies the
--   margins according to the new paper size.
pageSetupSetPaperSizeAndDefaultMargins :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> PaperSize -> m ()

-- | Sets the right margin of the <tt>GtkPageSetup</tt>.
pageSetupSetRightMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | Sets the top margin of the <tt>GtkPageSetup</tt>.
pageSetupSetTopMargin :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> Double -> Unit -> m ()

-- | This function saves the information from <i><tt>setup</tt></i> to
--   <i><tt>fileName</tt></i>.
pageSetupToFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> [Char] -> m ()

-- | Serialize page setup to an a{sv} variant.
pageSetupToGvariant :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> m GVariant

-- | This function adds the page setup from <i><tt>setup</tt></i> to
--   <i><tt>keyFile</tt></i>.
pageSetupToKeyFile :: (HasCallStack, MonadIO m, IsPageSetup a) => a -> KeyFile -> Maybe Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PageSetup.PageSetup
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PageSetup.PageSetup
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PageSetup.PageSetup
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PageSetup.PageSetup)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PageSetup.PageSetup o) => GI.Gtk.Objects.PageSetup.IsPageSetup o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PageSetup.PageSetup
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PageSetup.PageSetup


-- | The interface that is used to implement print preview.
--   
--   A <tt>GtkPrintOperationPreview</tt> object is passed to the
--   <a>PrintOperation::preview</a> signal by <a>PrintOperation</a>.
module GI.Gtk.Interfaces.PrintOperationPreview

-- | Memory-managed wrapper type.
newtype PrintOperationPreview
PrintOperationPreview :: ManagedPtr PrintOperationPreview -> PrintOperationPreview

-- | Type class for types which can be safely cast to
--   <a>PrintOperationPreview</a>, for instance with
--   <a>toPrintOperationPreview</a>.
class (GObject o, IsDescendantOf PrintOperationPreview o) => IsPrintOperationPreview o

-- | Cast to <a>PrintOperationPreview</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toPrintOperationPreview :: (MonadIO m, IsPrintOperationPreview o) => o -> m PrintOperationPreview

-- | Ends a preview.
--   
--   This function must be called to finish a custom print preview.
printOperationPreviewEndPreview :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> m ()

-- | Returns whether the given page is included in the set of pages that
--   have been selected for printing.
printOperationPreviewIsSelected :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> Int32 -> m Bool

-- | Renders a page to the preview.
--   
--   This is using the print context that was passed to the
--   <a>PrintOperation::preview</a> handler together with
--   <i><tt>preview</tt></i>.
--   
--   A custom print preview should use this function to render the
--   currently selected page.
--   
--   Note that this function requires a suitable cairo context to be
--   associated with the print context.
printOperationPreviewRenderPage :: (HasCallStack, MonadIO m, IsPrintOperationPreview a) => a -> Int32 -> m ()

-- | Emitted once for each page that gets rendered to the preview.
--   
--   A handler for this signal should update the <i><tt>context</tt></i>
--   according to <i><tt>pageSetup</tt></i> and set up a suitable cairo
--   context, using <a>printContextSetCairoContext</a>.
type PrintOperationPreviewGotPageSizeCallback = PrintContext -> PageSetup -> IO ()

-- | Connect a signal handler for the <a>gotPageSize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperationPreview #gotPageSize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPreviewGotPageSize :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewGotPageSizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>gotPageSize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperationPreview #gotPageSize callback
--   </pre>
onPrintOperationPreviewGotPageSize :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewGotPageSizeCallback) -> m SignalHandlerId

-- | The <a>ready</a> signal gets emitted once per preview operation,
--   before the first page is rendered.
--   
--   A handler for this signal can be used for setup tasks.
type PrintOperationPreviewReadyCallback = PrintContext -> IO ()

-- | Connect a signal handler for the <a>ready</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperationPreview #ready callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPreviewReady :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewReadyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>ready</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> printOperationPreview #ready callback
--   </pre>
onPrintOperationPreviewReady :: (IsPrintOperationPreview a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewReadyCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview o) => GI.Gtk.Interfaces.PrintOperationPreview.IsPrintOperationPreview o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.PrintOperationPreview.PrintOperationPreview


-- | A print backend.
module GI.Gtk.Structs.PrintBackend

-- | Memory-managed wrapper type.
newtype PrintBackend
PrintBackend :: ManagedPtr PrintBackend -> PrintBackend
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.PrintBackend.PrintBackend
instance GHC.Classes.Eq GI.Gtk.Structs.PrintBackend.PrintBackend
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.PrintBackend.PrintBackend


-- | Represents a printer.
--   
--   You only need to deal directly with printers if you use the
--   non-portable <a>PrintUnixDialog</a> API.
--   
--   A <tt>GtkPrinter</tt> allows to get status information about the
--   printer, such as its description, its location, the number of queued
--   jobs, etc. Most importantly, a <tt>GtkPrinter</tt> object can be used
--   to create a <a>PrintJob</a> object, which lets you print to the
--   printer.
module GI.Gtk.Objects.Printer

-- | Memory-managed wrapper type.
newtype Printer
Printer :: ManagedPtr Printer -> Printer

-- | Type class for types which can be safely cast to <a>Printer</a>, for
--   instance with <a>toPrinter</a>.
class (GObject o, IsDescendantOf Printer o) => IsPrinter o

-- | Cast to <a>Printer</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toPrinter :: (MonadIO m, IsPrinter o) => o -> m Printer

-- | Returns whether the printer accepts input in PDF format.
printerAcceptsPdf :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Returns whether the printer accepts input in PostScript format.
printerAcceptsPs :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Compares two printers.
printerCompare :: (HasCallStack, MonadIO m, IsPrinter a, IsPrinter b) => a -> b -> m Int32

-- | Returns the backend of the printer.
printerGetBackend :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m PrintBackend

-- | Returns the printer’s capabilities.
--   
--   This is useful when you’re using <tt>GtkPrintUnixDialog</tt>’s
--   manual-capabilities setting and need to know which settings the
--   printer can handle and which you must handle yourself.
--   
--   This will return 0 unless the printer’s details are available, see
--   <a>printerHasDetails</a> and <a>printerRequestDetails</a>.
printerGetCapabilities :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m [PrintCapabilities]

-- | Returns default page size of <i><tt>printer</tt></i>.
printerGetDefaultPageSize :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m PageSetup

-- | Gets the description of the printer.
printerGetDescription :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Text

-- | Retrieve the hard margins of <i><tt>printer</tt></i>.
--   
--   These are the margins that define the area at the borders of the paper
--   that the printer cannot print to.
--   
--   Note: This will not succeed unless the printer’s details are
--   available, see <a>printerHasDetails</a> and
--   <a>printerRequestDetails</a>.
printerGetHardMargins :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m (Bool, Double, Double, Double, Double)

-- | Retrieve the hard margins of <i><tt>printer</tt></i> for
--   <i><tt>paperSize</tt></i>.
--   
--   These are the margins that define the area at the borders of the paper
--   that the printer cannot print to.
--   
--   Note: This will not succeed unless the printer’s details are
--   available, see <a>printerHasDetails</a> and
--   <a>printerRequestDetails</a>.
printerGetHardMarginsForPaperSize :: (HasCallStack, MonadIO m, IsPrinter a) => a -> PaperSize -> m (Bool, Double, Double, Double, Double)

-- | Gets the name of the icon to use for the printer.
printerGetIconName :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Text

-- | Gets the number of jobs currently queued on the printer.
printerGetJobCount :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Int32

-- | Returns a description of the location of the printer.
printerGetLocation :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Text

-- | Returns the name of the printer.
printerGetName :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Text

-- | Returns the state message describing the current state of the printer.
printerGetStateMessage :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Text

-- | Returns whether the printer details are available.
printerHasDetails :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Returns whether the printer is accepting jobs
printerIsAcceptingJobs :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Returns whether the printer is currently active (i.e. accepts new
--   jobs).
printerIsActive :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Returns whether the printer is the default printer.
printerIsDefault :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Returns whether the printer is currently paused.
--   
--   A paused printer still accepts jobs, but it is not printing them.
printerIsPaused :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Returns whether the printer is virtual (i.e. does not represent actual
--   printer hardware, but something like a CUPS class).
printerIsVirtual :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m Bool

-- | Lists all the paper sizes <i><tt>printer</tt></i> supports.
--   
--   This will return and empty list unless the printer’s details are
--   available, see <a>printerHasDetails</a> and
--   <a>printerRequestDetails</a>.
printerListPapers :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m [PageSetup]

-- | Creates a new <tt>GtkPrinter</tt>.
printerNew :: (HasCallStack, MonadIO m) => Text -> PrintBackend -> Bool -> m Printer

-- | Requests the printer details.
--   
--   When the details are available, the <a>Printer::detailsAcquired</a>
--   signal will be emitted on <i><tt>printer</tt></i>.
printerRequestDetails :: (HasCallStack, MonadIO m, IsPrinter a) => a -> m ()

-- | Get the value of the “<tt>accepting-jobs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #acceptingJobs
--   </pre>
getPrinterAcceptingJobs :: (MonadIO m, IsPrinter o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accepts-pdf</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrinterAcceptsPdf :: (IsPrinter o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>accepts-pdf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #acceptsPdf
--   </pre>
getPrinterAcceptsPdf :: (MonadIO m, IsPrinter o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accepts-ps</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrinterAcceptsPs :: (IsPrinter o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>accepts-ps</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #acceptsPs
--   </pre>
getPrinterAcceptsPs :: (MonadIO m, IsPrinter o) => o -> m Bool

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #iconName
--   </pre>
getPrinterIconName :: (MonadIO m, IsPrinter o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-virtual</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrinterIsVirtual :: (IsPrinter o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-virtual</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #isVirtual
--   </pre>
getPrinterIsVirtual :: (MonadIO m, IsPrinter o) => o -> m Bool

-- | Get the value of the “<tt>job-count</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #jobCount
--   </pre>
getPrinterJobCount :: (MonadIO m, IsPrinter o) => o -> m Int32

-- | Get the value of the “<tt>location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #location
--   </pre>
getPrinterLocation :: (MonadIO m, IsPrinter o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrinterName :: (IsPrinter o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #name
--   </pre>
getPrinterName :: (MonadIO m, IsPrinter o) => o -> m Text

-- | Get the value of the “<tt>paused</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #paused
--   </pre>
getPrinterPaused :: (MonadIO m, IsPrinter o) => o -> m Bool

-- | Get the value of the “<tt>state-message</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printer #stateMessage
--   </pre>
getPrinterStateMessage :: (MonadIO m, IsPrinter o) => o -> m Text

-- | Emitted in response to a request for detailed information about a
--   printer from the print backend.
--   
--   The <i><tt>success</tt></i> parameter indicates if the information was
--   actually obtained.
type PrinterDetailsAcquiredCallback = Bool -> IO ()

-- | Connect a signal handler for the <a>detailsAcquired</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printer #detailsAcquired callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrinterDetailsAcquired :: (IsPrinter a, MonadIO m) => a -> ((?self :: a) => PrinterDetailsAcquiredCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>detailsAcquired</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printer #detailsAcquired callback
--   </pre>
onPrinterDetailsAcquired :: (IsPrinter a, MonadIO m) => a -> ((?self :: a) => PrinterDetailsAcquiredCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Printer.Printer
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Printer.Printer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Printer.Printer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Printer.Printer)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Printer.Printer o) => GI.Gtk.Objects.Printer.IsPrinter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Printer.Printer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Printer.Printer


-- | Meta-data to be passed to <a>recentManagerAddFull</a> when registering
--   a recently used resource.
module GI.Gtk.Structs.RecentData

-- | Memory-managed wrapper type.
newtype RecentData
RecentData :: ManagedPtr RecentData -> RecentData

-- | Construct a <a>RecentData</a> struct initialized to zero.
newZeroRecentData :: MonadIO m => m RecentData

-- | Set the value of the “<tt>app_exec</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #appExec
--   </pre>
clearRecentDataAppExec :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>app_exec</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #appExec
--   </pre>
getRecentDataAppExec :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>app_exec</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #appExec <a>:=</a> value ]
--   </pre>
setRecentDataAppExec :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>app_name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #appName
--   </pre>
clearRecentDataAppName :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>app_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #appName
--   </pre>
getRecentDataAppName :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>app_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #appName <a>:=</a> value ]
--   </pre>
setRecentDataAppName :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>description</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #description
--   </pre>
clearRecentDataDescription :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #description
--   </pre>
getRecentDataDescription :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #description <a>:=</a> value ]
--   </pre>
setRecentDataDescription :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>display_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #displayName
--   </pre>
clearRecentDataDisplayName :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #displayName
--   </pre>
getRecentDataDisplayName :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>display_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #displayName <a>:=</a> value ]
--   </pre>
setRecentDataDisplayName :: MonadIO m => RecentData -> CString -> m ()

-- | Set the value of the “<tt>groups</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #groups
--   </pre>
clearRecentDataGroups :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>groups</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #groups
--   </pre>
getRecentDataGroups :: MonadIO m => RecentData -> m (Maybe [Text])

-- | Set the value of the “<tt>groups</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #groups <a>:=</a> value ]
--   </pre>
setRecentDataGroups :: MonadIO m => RecentData -> Ptr CString -> m ()

-- | Get the value of the “<tt>is_private</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #isPrivate
--   </pre>
getRecentDataIsPrivate :: MonadIO m => RecentData -> m Bool

-- | Set the value of the “<tt>is_private</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #isPrivate <a>:=</a> value ]
--   </pre>
setRecentDataIsPrivate :: MonadIO m => RecentData -> Bool -> m ()

-- | Set the value of the “<tt>mime_type</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #mimeType
--   </pre>
clearRecentDataMimeType :: MonadIO m => RecentData -> m ()

-- | Get the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentData #mimeType
--   </pre>
getRecentDataMimeType :: MonadIO m => RecentData -> m (Maybe Text)

-- | Set the value of the “<tt>mime_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> recentData [ #mimeType <a>:=</a> value ]
--   </pre>
setRecentDataMimeType :: MonadIO m => RecentData -> CString -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.RecentData.RecentData
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.RecentData.RecentData
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RecentData.RecentData tag
instance GHC.Classes.Eq GI.Gtk.Structs.RecentData.RecentData
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.RecentData.RecentData


-- | Contains the metadata associated with an item in the recently used
--   files list.
module GI.Gtk.Structs.RecentInfo

-- | Memory-managed wrapper type.
newtype RecentInfo
RecentInfo :: ManagedPtr RecentInfo -> RecentInfo

-- | Creates a <tt>GAppInfo</tt> for the specified <tt>GtkRecentInfo</tt>
--   
--   In case of error, <i><tt>error</tt></i> will be set either with a
--   <tt><i>GTK_RECENT_MANAGER_ERROR</i></tt> or a
--   <tt><i>G_IO_ERROR</i></tt>
recentInfoCreateAppInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Maybe Text -> m (Maybe AppInfo)

-- | Checks whether the resource pointed by <i><tt>info</tt></i> still
--   exists. At the moment this check is done only on resources pointing to
--   local files.
recentInfoExists :: (HasCallStack, MonadIO m) => RecentInfo -> m Bool

-- | Gets the time when the resource was added to the recently used
--   resources list.
recentInfoGetAdded :: (HasCallStack, MonadIO m) => RecentInfo -> m DateTime

-- | Gets the number of days elapsed since the last update of the resource
--   pointed by <i><tt>info</tt></i>.
recentInfoGetAge :: (HasCallStack, MonadIO m) => RecentInfo -> m Int32

-- | Gets the data regarding the application that has registered the
--   resource pointed by <i><tt>info</tt></i>.
--   
--   If the command line contains any escape characters defined inside the
--   storage specification, they will be expanded.
recentInfoGetApplicationInfo :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m (Bool, Text, Word32, DateTime)

-- | Retrieves the list of applications that have registered this resource.
recentInfoGetApplications :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], CSize)

-- | Gets the (short) description of the resource.
recentInfoGetDescription :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets the name of the resource.
--   
--   If none has been defined, the basename of the resource is obtained.
recentInfoGetDisplayName :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Retrieves the icon associated to the resource MIME type.
recentInfoGetGicon :: (HasCallStack, MonadIO m) => RecentInfo -> m (Maybe Icon)

-- | Returns all groups registered for the recently used item
--   <i><tt>info</tt></i>.
--   
--   The array of returned group names will be <a>Nothing</a> terminated,
--   so length might optionally be <a>Nothing</a>.
recentInfoGetGroups :: (HasCallStack, MonadIO m) => RecentInfo -> m ([Text], CSize)

-- | Gets the MIME type of the resource.
recentInfoGetMimeType :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets the time when the meta-data for the resource was last modified.
recentInfoGetModified :: (HasCallStack, MonadIO m) => RecentInfo -> m DateTime

-- | Gets the value of the “private” flag.
--   
--   Resources in the recently used list that have this flag set to
--   <a>True</a> should only be displayed by the applications that have
--   registered them.
recentInfoGetPrivateHint :: (HasCallStack, MonadIO m) => RecentInfo -> m Bool

-- | Computes a valid UTF-8 string that can be used as the name of the item
--   in a menu or list.
--   
--   For example, calling this function on an item that refers to
--   “file:///foo/bar.txt” will yield “bar.txt”.
recentInfoGetShortName :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets the URI of the resource.
recentInfoGetUri :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Gets a displayable version of the resource’s URI.
--   
--   If the resource is local, it returns a local path; if the resource is
--   not local, it returns the UTF-8 encoded content of
--   <a>recentInfoGetUri</a>.
recentInfoGetUriDisplay :: (HasCallStack, MonadIO m) => RecentInfo -> m (Maybe Text)

-- | Gets the time when the meta-data for the resource was last visited.
recentInfoGetVisited :: (HasCallStack, MonadIO m) => RecentInfo -> m DateTime

-- | Checks whether an application registered this resource using
--   <i><tt>appName</tt></i>.
recentInfoHasApplication :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m Bool

-- | Checks whether <i><tt>groupName</tt></i> appears inside the groups
--   registered for the recently used item <i><tt>info</tt></i>.
recentInfoHasGroup :: (HasCallStack, MonadIO m) => RecentInfo -> Text -> m Bool

-- | Checks whether the resource is local or not by looking at the scheme
--   of its URI.
recentInfoIsLocal :: (HasCallStack, MonadIO m) => RecentInfo -> m Bool

-- | Gets the name of the last application that have registered the
--   recently used resource represented by <i><tt>info</tt></i>.
recentInfoLastApplication :: (HasCallStack, MonadIO m) => RecentInfo -> m Text

-- | Checks whether two <tt>GtkRecentInfo</tt> point to the same resource.
recentInfoMatch :: (HasCallStack, MonadIO m) => RecentInfo -> RecentInfo -> m Bool

-- | Increases the reference count of <i><tt>recentInfo</tt></i> by one.
recentInfoRef :: (HasCallStack, MonadIO m) => RecentInfo -> m RecentInfo

-- | Decreases the reference count of <i><tt>info</tt></i> by one.
--   
--   If the reference count reaches zero, <i><tt>info</tt></i> is
--   deallocated, and the memory freed.
recentInfoUnref :: (HasCallStack, MonadIO m) => RecentInfo -> m ()
instance GHC.Classes.Eq GI.Gtk.Structs.RecentInfo.RecentInfo
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.RecentInfo.RecentInfo
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.RecentInfo.RecentInfo
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.RecentInfo.RecentInfo)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.RecentInfo.RecentInfo
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.RecentInfo.RecentInfo


-- | Manages and looks up recently used files.
--   
--   Each recently used file is identified by its URI, and has meta-data
--   associated to it, like the names and command lines of the applications
--   that have registered it, the number of time each application has
--   registered the same file, the mime type of the file and whether the
--   file should be displayed only by the applications that have registered
--   it.
--   
--   The recently used files list is per user.
--   
--   <tt>GtkRecentManager</tt> acts like a database of all the recently
--   used files. You can create new <tt>GtkRecentManager</tt> objects, but
--   it is more efficient to use the default manager created by GTK.
--   
--   Adding a new recently used file is as simple as:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkRecentManager *manager;
--   
--   manager = gtk_recent_manager_get_default ();
--   gtk_recent_manager_add_item (manager, file_uri);
--   </pre>
--   
--   The <tt>GtkRecentManager</tt> will try to gather all the needed
--   information from the file itself through GIO.
--   
--   Looking up the meta-data associated with a recently used file given
--   its URI requires calling <a>recentManagerLookupItem</a>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkRecentManager *manager;
--   GtkRecentInfo *info;
--   GError *error = NULL;
--   
--   manager = gtk_recent_manager_get_default ();
--   info = gtk_recent_manager_lookup_item (manager, file_uri, &amp;error);
--   if (error)
--     {
--       g_warning ("Could not find the file: %s", error-&gt;message);
--       g_error_free (error);
--     }
--   else
--    {
--      // Use the info object
--      gtk_recent_info_unref (info);
--    }
--   </pre>
--   
--   In order to retrieve the list of recently used files, you can use
--   <a>recentManagerGetItems</a>, which returns a list of
--   <a>RecentInfo</a>.
--   
--   Note that the maximum age of the recently used files list is
--   controllable through the <a>Settings:gtkRecentFilesMaxAge</a>
--   property.
module GI.Gtk.Objects.RecentManager

-- | Memory-managed wrapper type.
newtype RecentManager
RecentManager :: ManagedPtr RecentManager -> RecentManager

-- | Type class for types which can be safely cast to <a>RecentManager</a>,
--   for instance with <a>toRecentManager</a>.
class (GObject o, IsDescendantOf RecentManager o) => IsRecentManager o

-- | Cast to <a>RecentManager</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRecentManager :: (MonadIO m, IsRecentManager o) => o -> m RecentManager

-- | Adds a new resource, pointed by <i><tt>uri</tt></i>, into the recently
--   used resources list, using the metadata specified inside the
--   <tt>GtkRecentData</tt> passed in <i><tt>recentData</tt></i>.
--   
--   The passed URI will be used to identify this resource inside the list.
--   
--   In order to register the new recently used resource, metadata about
--   the resource must be passed as well as the URI; the metadata is stored
--   in a <tt>GtkRecentData</tt>, which must contain the MIME type of the
--   resource pointed by the URI; the name of the application that is
--   registering the item, and a command line to be used when launching the
--   item.
--   
--   Optionally, a <tt>GtkRecentData</tt> might contain a UTF-8 string to
--   be used when viewing the item instead of the last component of the
--   URI; a short description of the item; whether the item should be
--   considered private - that is, should be displayed only by the
--   applications that have registered it.
recentManagerAddFull :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> RecentData -> m Bool

-- | Adds a new resource, pointed by <i><tt>uri</tt></i>, into the recently
--   used resources list.
--   
--   This function automatically retrieves some of the needed metadata and
--   setting other metadata to common default values; it then feeds the
--   data to <a>recentManagerAddFull</a>.
--   
--   See <a>recentManagerAddFull</a> if you want to explicitly define the
--   metadata for the resource pointed by <i><tt>uri</tt></i>.
recentManagerAddItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m Bool

-- | Gets a unique instance of <tt>GtkRecentManager</tt> that you can share
--   in your application without caring about memory management.
recentManagerGetDefault :: (HasCallStack, MonadIO m) => m RecentManager

-- | Gets the list of recently used resources.
recentManagerGetItems :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m [RecentInfo]

-- | Checks whether there is a recently used resource registered with
--   <i><tt>uri</tt></i> inside the recent manager.
recentManagerHasItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m Bool

-- | Searches for a URI inside the recently used resources list, and
--   returns a <tt>GtkRecentInfo</tt> containing information about the
--   resource like its MIME type, or its display name.
recentManagerLookupItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m (Maybe RecentInfo)

-- | Changes the location of a recently used resource from
--   <i><tt>uri</tt></i> to <i><tt>newUri</tt></i>.
--   
--   Please note that this function will not affect the resource pointed by
--   the URIs, but only the URI used in the recently used resources list.
recentManagerMoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> Maybe Text -> m ()

-- | Creates a new recent manager object.
--   
--   Recent manager objects are used to handle the list of recently used
--   resources. A <tt>GtkRecentManager</tt> object monitors the recently
--   used resources list, and emits the <a>RecentManager::changed</a>
--   signal each time something inside the list changes.
--   
--   <tt>GtkRecentManager</tt> objects are expensive: be sure to create
--   them only when needed. You should use <a>recentManagerGetDefault</a>
--   instead.
recentManagerNew :: (HasCallStack, MonadIO m) => m RecentManager

-- | Purges every item from the recently used resources list.
recentManagerPurgeItems :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> m Int32

-- | Removes a resource pointed by <i><tt>uri</tt></i> from the recently
--   used resources list handled by a recent manager.
recentManagerRemoveItem :: (HasCallStack, MonadIO m, IsRecentManager a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filename</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRecentManagerFilename :: (IsRecentManager o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>filename</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentManager #filename
--   </pre>
getRecentManagerFilename :: (MonadIO m, IsRecentManager o) => o -> m (Maybe Text)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> recentManager #size
--   </pre>
getRecentManagerSize :: (MonadIO m, IsRecentManager o) => o -> m Int32

-- | Emitted when the current recently used resources manager changes its
--   contents.
--   
--   This can happen either by calling <a>recentManagerAddItem</a> or by
--   another application.
type RecentManagerChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> recentManager #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRecentManagerChanged :: (IsRecentManager a, MonadIO m) => a -> ((?self :: a) => RecentManagerChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> recentManager #changed callback
--   </pre>
onRecentManagerChanged :: (IsRecentManager a, MonadIO m) => a -> ((?self :: a) => RecentManagerChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.RecentManager.RecentManager
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.RecentManager.RecentManager
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.RecentManager.RecentManager
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.RecentManager.RecentManager)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.RecentManager.RecentManager o) => GI.Gtk.Objects.RecentManager.IsRecentManager o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.RecentManager.RecentManager
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.RecentManager.RecentManager


-- | Represents a request of a screen object in a given orientation.
--   
--   These are primarily used in container implementations when allocating
--   a natural size for children. See
--   [func<i><tt>distributeNaturalAllocation</tt></i>].
module GI.Gtk.Structs.RequestedSize

-- | Memory-managed wrapper type.
newtype RequestedSize
RequestedSize :: ManagedPtr RequestedSize -> RequestedSize

-- | Construct a <a>RequestedSize</a> struct initialized to zero.
newZeroRequestedSize :: MonadIO m => m RequestedSize

-- | Set the value of the “<tt>data</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #data
--   </pre>
clearRequestedSizeData :: MonadIO m => RequestedSize -> m ()

-- | Get the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requestedSize #data
--   </pre>
getRequestedSizeData :: MonadIO m => RequestedSize -> m (Ptr ())

-- | Set the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requestedSize [ #data <a>:=</a> value ]
--   </pre>
setRequestedSizeData :: MonadIO m => RequestedSize -> Ptr () -> m ()

-- | Get the value of the “<tt>minimum_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requestedSize #minimumSize
--   </pre>
getRequestedSizeMinimumSize :: MonadIO m => RequestedSize -> m Int32

-- | Set the value of the “<tt>minimum_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requestedSize [ #minimumSize <a>:=</a> value ]
--   </pre>
setRequestedSizeMinimumSize :: MonadIO m => RequestedSize -> Int32 -> m ()

-- | Get the value of the “<tt>natural_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requestedSize #naturalSize
--   </pre>
getRequestedSizeNaturalSize :: MonadIO m => RequestedSize -> m Int32

-- | Set the value of the “<tt>natural_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requestedSize [ #naturalSize <a>:=</a> value ]
--   </pre>
setRequestedSizeNaturalSize :: MonadIO m => RequestedSize -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.RequestedSize.RequestedSize
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.RequestedSize.RequestedSize
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.RequestedSize.RequestedSize tag
instance GHC.Classes.Eq GI.Gtk.Structs.RequestedSize.RequestedSize
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.RequestedSize.RequestedSize


-- | Represents the desired size of a widget.
--   
--   See <a>GtkWidget’s geometry management section</a> for more
--   information.
module GI.Gtk.Structs.Requisition

-- | Memory-managed wrapper type.
newtype Requisition
Requisition :: ManagedPtr Requisition -> Requisition

-- | Construct a <a>Requisition</a> struct initialized to zero.
newZeroRequisition :: MonadIO m => m Requisition

-- | Copies a <tt>GtkRequisition</tt>.
requisitionCopy :: (HasCallStack, MonadIO m) => Requisition -> m Requisition

-- | Frees a <tt>GtkRequisition</tt>.
requisitionFree :: (HasCallStack, MonadIO m) => Requisition -> m ()

-- | Allocates a new <tt>GtkRequisition</tt>.
--   
--   The struct is initialized to zero.
requisitionNew :: (HasCallStack, MonadIO m) => m Requisition

-- | Get the value of the “<tt>height</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requisition #height
--   </pre>
getRequisitionHeight :: MonadIO m => Requisition -> m Int32

-- | Set the value of the “<tt>height</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requisition [ #height <a>:=</a> value ]
--   </pre>
setRequisitionHeight :: MonadIO m => Requisition -> Int32 -> m ()

-- | Get the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> requisition #width
--   </pre>
getRequisitionWidth :: MonadIO m => Requisition -> m Int32

-- | Set the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> requisition [ #width <a>:=</a> value ]
--   </pre>
setRequisitionWidth :: MonadIO m => Requisition -> Int32 -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.Requisition.Requisition tag
instance GHC.Classes.Eq GI.Gtk.Structs.Requisition.Requisition
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.Requisition.Requisition
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.Requisition.Requisition
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.Requisition.Requisition)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.Requisition.Requisition
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.Requisition.Requisition


-- | Provides detailed information on how a scroll operation should be
--   performed.
--   
--   Scrolling functions usually allow passing a <tt>NULL</tt> scroll info
--   which will cause the default values to be used and just scroll the
--   element into view.
--   
--   <i>Since: 4.12</i>
module GI.Gtk.Structs.ScrollInfo

-- | Memory-managed wrapper type.
newtype ScrollInfo
ScrollInfo :: ManagedPtr ScrollInfo -> ScrollInfo

-- | Checks if horizontal scrolling is enabled.
--   
--   <i>Since: 4.12</i>
scrollInfoGetEnableHorizontal :: (HasCallStack, MonadIO m) => ScrollInfo -> m Bool

-- | Checks if vertical scrolling is enabled.
--   
--   <i>Since: 4.12</i>
scrollInfoGetEnableVertical :: (HasCallStack, MonadIO m) => ScrollInfo -> m Bool

-- | Creates a new scroll info for scrolling an element into view.
--   
--   <i>Since: 4.12</i>
scrollInfoNew :: (HasCallStack, MonadIO m) => m ScrollInfo

-- | Increases the reference count of a <tt>GtkScrollInfo</tt> by one.
--   
--   <i>Since: 4.12</i>
scrollInfoRef :: (HasCallStack, MonadIO m) => ScrollInfo -> m ScrollInfo

-- | Turns horizontal scrolling on or off.
--   
--   <i>Since: 4.12</i>
scrollInfoSetEnableHorizontal :: (HasCallStack, MonadIO m) => ScrollInfo -> Bool -> m ()

-- | Turns vertical scrolling on or off.
--   
--   <i>Since: 4.12</i>
scrollInfoSetEnableVertical :: (HasCallStack, MonadIO m) => ScrollInfo -> Bool -> m ()

-- | Decreases the reference count of a <tt>GtkScrollInfo</tt> by one.
--   
--   If the resulting reference count is zero, frees the self.
--   
--   <i>Since: 4.12</i>
scrollInfoUnref :: (HasCallStack, MonadIO m) => ScrollInfo -> m ()
instance GHC.Classes.Eq GI.Gtk.Structs.ScrollInfo.ScrollInfo
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.ScrollInfo.ScrollInfo
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.ScrollInfo.ScrollInfo
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.ScrollInfo.ScrollInfo)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.ScrollInfo.ScrollInfo
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.ScrollInfo.ScrollInfo


-- | Provides information about a location in an SVG document.
--   
--   The information should be considered approximate; it is meant to
--   provide feedback for errors in an editor.
--   
--   <i>Since: 4.22</i>
module GI.Gtk.Structs.SvgLocation

-- | Memory-managed wrapper type.
newtype SvgLocation
SvgLocation :: ManagedPtr SvgLocation -> SvgLocation

-- | Construct a <a>SvgLocation</a> struct initialized to zero.
newZeroSvgLocation :: MonadIO m => m SvgLocation

-- | Get the value of the “<tt>bytes</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svgLocation #bytes
--   </pre>
getSvgLocationBytes :: MonadIO m => SvgLocation -> m CSize

-- | Set the value of the “<tt>bytes</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svgLocation [ #bytes <a>:=</a> value ]
--   </pre>
setSvgLocationBytes :: MonadIO m => SvgLocation -> CSize -> m ()

-- | Get the value of the “<tt>line_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svgLocation #lineChars
--   </pre>
getSvgLocationLineChars :: MonadIO m => SvgLocation -> m CSize

-- | Set the value of the “<tt>line_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svgLocation [ #lineChars <a>:=</a> value ]
--   </pre>
setSvgLocationLineChars :: MonadIO m => SvgLocation -> CSize -> m ()

-- | Get the value of the “<tt>lines</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> svgLocation #lines
--   </pre>
getSvgLocationLines :: MonadIO m => SvgLocation -> m CSize

-- | Set the value of the “<tt>lines</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> svgLocation [ #lines <a>:=</a> value ]
--   </pre>
setSvgLocationLines :: MonadIO m => SvgLocation -> CSize -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.SvgLocation.SvgLocation
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.SvgLocation.SvgLocation
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.SvgLocation.SvgLocation tag
instance GHC.Classes.Eq GI.Gtk.Structs.SvgLocation.SvgLocation
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.SvgLocation.SvgLocation


-- | The <tt>GtkTreeIter</tt> is the primary structure for accessing a
--   <tt>GtkTreeModel</tt>. Models are expected to put a unique integer in
--   the <i><tt>stamp</tt></i> member, and put model-specific data in the
--   three <i><tt>userData</tt></i> members.
module GI.Gtk.Structs.TreeIter

-- | Memory-managed wrapper type.
newtype TreeIter
TreeIter :: ManagedPtr TreeIter -> TreeIter

-- | Construct a <a>TreeIter</a> struct initialized to zero.
newZeroTreeIter :: MonadIO m => m TreeIter

-- | Creates a dynamically allocated tree iterator as a copy of
--   <i><tt>iter</tt></i>.
--   
--   This function is not intended for use in applications, because you can
--   just copy the structs by value (<tt>GtkTreeIter new_iter =
--   iter;</tt>). You must free this iter with <a>treeIterFree</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeIterCopy :: (HasCallStack, MonadIO m) => TreeIter -> m TreeIter

-- | Frees an iterator that has been allocated by <a>treeIterCopy</a>.
--   
--   This function is mainly used for language bindings.

-- | <i>Deprecated: (Since version 4.10)</i>
treeIterFree :: (HasCallStack, MonadIO m) => TreeIter -> m ()

-- | Get the value of the “<tt>stamp</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #stamp
--   </pre>
getTreeIterStamp :: MonadIO m => TreeIter -> m Int32

-- | Set the value of the “<tt>stamp</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #stamp <a>:=</a> value ]
--   </pre>
setTreeIterStamp :: MonadIO m => TreeIter -> Int32 -> m ()

-- | Set the value of the “<tt>user_data</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #userData
--   </pre>
clearTreeIterUserData :: MonadIO m => TreeIter -> m ()

-- | Get the value of the “<tt>user_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #userData
--   </pre>
getTreeIterUserData :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “<tt>user_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #userData <a>:=</a> value ]
--   </pre>
setTreeIterUserData :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “<tt>user_data2</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #userData2
--   </pre>
clearTreeIterUserData2 :: MonadIO m => TreeIter -> m ()

-- | Get the value of the “<tt>user_data2</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #userData2
--   </pre>
getTreeIterUserData2 :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “<tt>user_data2</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #userData2 <a>:=</a> value ]
--   </pre>
setTreeIterUserData2 :: MonadIO m => TreeIter -> Ptr () -> m ()

-- | Set the value of the “<tt>user_data3</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #userData3
--   </pre>
clearTreeIterUserData3 :: MonadIO m => TreeIter -> m ()

-- | Get the value of the “<tt>user_data3</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeIter #userData3
--   </pre>
getTreeIterUserData3 :: MonadIO m => TreeIter -> m (Ptr ())

-- | Set the value of the “<tt>user_data3</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeIter [ #userData3 <a>:=</a> value ]
--   </pre>
setTreeIterUserData3 :: MonadIO m => TreeIter -> Ptr () -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TreeIter.TreeIter tag
instance GHC.Classes.Eq GI.Gtk.Structs.TreeIter.TreeIter
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.TreeIter.TreeIter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.TreeIter.TreeIter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.TreeIter.TreeIter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.TreeIter.TreeIter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.TreeIter.TreeIter


-- | An opaque structure representing a path to a row in a model.
module GI.Gtk.Structs.TreePath

-- | Memory-managed wrapper type.
newtype TreePath
TreePath :: ManagedPtr TreePath -> TreePath

-- | Appends a new index to a path.
--   
--   As a result, the depth of the path is increased.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathAppendIndex :: (HasCallStack, MonadIO m) => TreePath -> Int32 -> m ()

-- | Compares two paths.
--   
--   If <i><tt>a</tt></i> appears before <i><tt>b</tt></i> in a tree, then
--   -1 is returned. If <i><tt>b</tt></i> appears before <i><tt>a</tt></i>,
--   then 1 is returned. If the two nodes are equal, then 0 is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathCompare :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Int32

-- | Creates a new <tt>GtkTreePath</tt> as a copy of <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathCopy :: (HasCallStack, MonadIO m) => TreePath -> m TreePath

-- | Moves <i><tt>path</tt></i> to point to the first child of the current
--   path.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathDown :: (HasCallStack, MonadIO m) => TreePath -> m ()

-- | Frees <i><tt>path</tt></i>. If <i><tt>path</tt></i> is <a>Nothing</a>,
--   it simply returns.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathFree :: (HasCallStack, MonadIO m) => Maybe TreePath -> m ()

-- | Returns the current depth of <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathGetDepth :: (HasCallStack, MonadIO m) => TreePath -> m Int32

-- | Returns the current indices of <i><tt>path</tt></i>.
--   
--   This is an array of integers, each representing a node in a tree. It
--   also returns the number of elements in the array. The array should not
--   be freed.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathGetIndices :: (HasCallStack, MonadIO m) => TreePath -> m (Maybe [Int32])

-- | Returns <a>True</a> if <i><tt>descendant</tt></i> is a descendant of
--   <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathIsAncestor :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Bool

-- | Returns <a>True</a> if <i><tt>path</tt></i> is a descendant of
--   <i><tt>ancestor</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathIsDescendant :: (HasCallStack, MonadIO m) => TreePath -> TreePath -> m Bool

-- | Creates a new <tt>GtkTreePath</tt> This refers to a row.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathNew :: (HasCallStack, MonadIO m) => m TreePath

-- | Creates a new <tt>GtkTreePath</tt>.
--   
--   The string representation of this path is “0”.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathNewFirst :: (HasCallStack, MonadIO m) => m TreePath

-- | Creates a new path with the given <i><tt>indices</tt></i> array of
--   <i><tt>length</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathNewFromIndices :: (HasCallStack, MonadIO m) => [Int32] -> m TreePath

-- | Creates a new <tt>GtkTreePath</tt> initialized to
--   <i><tt>path</tt></i>.
--   
--   <i><tt>path</tt></i> is expected to be a colon separated list of
--   numbers. For example, the string “10:4:0” would create a path of depth
--   3 pointing to the 11th child of the root node, the 5th child of that
--   11th child, and the 1st child of that 5th child. If an invalid path
--   string is passed in, <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathNewFromString :: (HasCallStack, MonadIO m) => Text -> m (Maybe TreePath)

-- | Moves the <i><tt>path</tt></i> to point to the next node at the
--   current depth.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathNext :: (HasCallStack, MonadIO m) => TreePath -> m ()

-- | Prepends a new index to a path.
--   
--   As a result, the depth of the path is increased.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathPrependIndex :: (HasCallStack, MonadIO m) => TreePath -> Int32 -> m ()

-- | Moves the <i><tt>path</tt></i> to point to the previous node at the
--   current depth, if it exists.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathPrev :: (HasCallStack, MonadIO m) => TreePath -> m Bool

-- | 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. If the
--   path has depth 0, <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathToString :: (HasCallStack, MonadIO m) => TreePath -> m (Maybe Text)

-- | Moves the <i><tt>path</tt></i> to point to its parent node, if it has
--   a parent.

-- | <i>Deprecated: (Since version 4.10)</i>
treePathUp :: (HasCallStack, MonadIO m) => TreePath -> m Bool
instance GHC.Classes.Eq GI.Gtk.Structs.TreePath.TreePath
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.TreePath.TreePath
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.TreePath.TreePath
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.TreePath.TreePath)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.TreePath.TreePath
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.TreePath.TreePath


-- | Interface for Drag-and-Drop destinations in <tt>GtkTreeView</tt>.
module GI.Gtk.Interfaces.TreeDragSource

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)List views use widgets to display
--   their contents.You can use <a>DragSource</a> to implement a drag
--   source</i>
newtype TreeDragSource

-- | <i>Deprecated: (Since version 4.10)List views use widgets to display
--   their contents.You can use <a>DragSource</a> to implement a drag
--   source</i>
TreeDragSource :: ManagedPtr TreeDragSource -> TreeDragSource

-- | Type class for types which implement <a>TreeDragSource</a>.
class (ManagedPtrNewtype o, IsDescendantOf TreeDragSource o) => IsTreeDragSource o

-- | Asks the <tt>GtkTreeDragSource</tt> to delete the row at
--   <i><tt>path</tt></i>, because it was moved somewhere else via
--   drag-and-drop. Returns <a>False</a> if the deletion fails because
--   <i><tt>path</tt></i> no longer exists, or for some model-specific
--   reason. Should robustly handle a <i><tt>path</tt></i> no longer found
--   in the model!

-- | <i>Deprecated: (Since version 4.10)Use list models instead</i>
treeDragSourceDragDataDelete :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> m Bool

-- | Asks the <tt>GtkTreeDragSource</tt> to return a
--   <tt>GdkContentProvider</tt> representing the row at
--   <i><tt>path</tt></i>. Should robustly handle a <i><tt>path</tt></i> no
--   longer found in the model!

-- | <i>Deprecated: (Since version 4.10)Use list models instead</i>
treeDragSourceDragDataGet :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> m (Maybe ContentProvider)

-- | Asks the <tt>GtkTreeDragSource</tt> whether a particular row can be
--   used as the source of a DND operation. If the source doesn’t implement
--   this interface, the row is assumed draggable.

-- | <i>Deprecated: (Since version 4.10)Use list models instead</i>
treeDragSourceRowDraggable :: (HasCallStack, MonadIO m, IsTreeDragSource a) => a -> TreePath -> m Bool
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Interfaces.TreeDragSource.TreeDragSource
instance GHC.Classes.Eq GI.Gtk.Interfaces.TreeDragSource.TreeDragSource
instance (Data.GI.Base.BasicTypes.ManagedPtrNewtype o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.TreeDragSource.TreeDragSource o) => GI.Gtk.Interfaces.TreeDragSource.IsTreeDragSource o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.TreeDragSource.TreeDragSource


-- | Interface for Drag-and-Drop destinations in <tt>GtkTreeView</tt>.
module GI.Gtk.Interfaces.TreeDragDest

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)List views use widgets to display
--   their contents.You can use <a>DropTarget</a> to implement a drop
--   destination</i>
newtype TreeDragDest

-- | <i>Deprecated: (Since version 4.10)List views use widgets to display
--   their contents.You can use <a>DropTarget</a> to implement a drop
--   destination</i>
TreeDragDest :: ManagedPtr TreeDragDest -> TreeDragDest

-- | Type class for types which implement <a>TreeDragDest</a>.
class (ManagedPtrNewtype o, IsDescendantOf TreeDragDest o) => IsTreeDragDest o

-- | Asks the <tt>GtkTreeDragDest</tt> to insert a row before the path
--   <i><tt>dest</tt></i>, deriving the contents of the row from
--   <i><tt>value</tt></i>. If <i><tt>dest</tt></i> is outside the tree so
--   that inserting before it is impossible, <a>False</a> will be returned.
--   Also, <a>False</a> may be returned if the new row is not created for
--   some model-specific reason. Should robustly handle a
--   <i><tt>dest</tt></i> no longer found in the model!

-- | <i>Deprecated: (Since version 4.10)Use list models instead</i>
treeDragDestDragDataReceived :: (HasCallStack, MonadIO m, IsTreeDragDest a) => a -> TreePath -> GValue -> m Bool

-- | Determines whether a drop is possible before the given
--   <i><tt>destPath</tt></i>, at the same depth as
--   <i><tt>destPath</tt></i>. i.e., can we drop the data in
--   <i><tt>value</tt></i> at that location. <i><tt>destPath</tt></i> does
--   not have to exist; the return value will almost certainly be
--   <a>False</a> if the parent of <i><tt>destPath</tt></i> doesn’t exist,
--   though.

-- | <i>Deprecated: (Since version 4.10)Use list models instead</i>
treeDragDestRowDropPossible :: (HasCallStack, MonadIO m, IsTreeDragDest a) => a -> TreePath -> GValue -> m Bool
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Interfaces.TreeDragDest.TreeDragDest
instance GHC.Classes.Eq GI.Gtk.Interfaces.TreeDragDest.TreeDragDest
instance (Data.GI.Base.BasicTypes.ManagedPtrNewtype o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.TreeDragDest.TreeDragDest o) => GI.Gtk.Interfaces.TreeDragDest.IsTreeDragDest o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.TreeDragDest.TreeDragDest


module GI.Gtk.Callbacks

-- | Type of callback used to calculate the next page in a
--   <tt>GtkAssistant</tt>.
--   
--   It’s called both for computing the next page when the user presses the
--   “forward” button and for handling the behavior of the “last” button.
--   
--   See <a>assistantSetForwardPageFunc</a>.
type AssistantPageFunc = Int32 -> IO Int32

-- | Type of callback used to calculate the next page in a
--   <tt>GtkAssistant</tt>.
--   
--   It’s called both for computing the next page when the user presses the
--   “forward” button and for handling the behavior of the “last” button.
--   
--   See <a>assistantSetForwardPageFunc</a>.
type AssistantPageFunc_WithClosures = Int32 -> Ptr () -> IO Int32

-- | Type for the callback on the (unwrapped) C side.
type C_AssistantPageFunc = Int32 -> Ptr () -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AssistantPageFunc :: AssistantPageFunc -> AssistantPageFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AssistantPageFunc :: (HasCallStack, MonadIO m) => FunPtr C_AssistantPageFunc -> Int32 -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AssistantPageFunc :: MonadIO m => AssistantPageFunc -> m (GClosure C_AssistantPageFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AssistantPageFunc</a>.
mk_AssistantPageFunc :: C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AssistantPageFunc</a></tt>.
noAssistantPageFunc :: Maybe AssistantPageFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AssistantPageFunc_WithClosures</a></tt>.
noAssistantPageFunc_WithClosures :: Maybe AssistantPageFunc_WithClosures

-- | Wrap a <a>AssistantPageFunc</a> into a <a>C_AssistantPageFunc</a>.
wrap_AssistantPageFunc :: Maybe (Ptr (FunPtr C_AssistantPageFunc)) -> AssistantPageFunc_WithClosures -> C_AssistantPageFunc

-- | <i>No description available in the introspection data.</i>
type BuildableParserEndElementFieldCallback = BuildableParseContext -> Text -> IO ()

-- | <i>No description available in the introspection data.</i>
type BuildableParserEndElementFieldCallback_WithClosures = BuildableParseContext -> Text -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_BuildableParserEndElementFieldCallback = Ptr BuildableParseContext -> CString -> Ptr () -> Ptr Ptr GError -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BuildableParserEndElementFieldCallback :: BuildableParserEndElementFieldCallback -> BuildableParserEndElementFieldCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_BuildableParserEndElementFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserEndElementFieldCallback -> BuildableParseContext -> Text -> Ptr () -> m ()

-- | Generate a function pointer callable from C code, from a
--   <a>C_BuildableParserEndElementFieldCallback</a>.
mk_BuildableParserEndElementFieldCallback :: C_BuildableParserEndElementFieldCallback -> IO (FunPtr C_BuildableParserEndElementFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserEndElementFieldCallback</a></tt>.
noBuildableParserEndElementFieldCallback :: Maybe BuildableParserEndElementFieldCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserEndElementFieldCallback_WithClosures</a></tt>.
noBuildableParserEndElementFieldCallback_WithClosures :: Maybe BuildableParserEndElementFieldCallback_WithClosures

-- | <i>No description available in the introspection data.</i>
type BuildableParserErrorFieldCallback = BuildableParseContext -> GError -> IO ()

-- | <i>No description available in the introspection data.</i>
type BuildableParserErrorFieldCallback_WithClosures = BuildableParseContext -> GError -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_BuildableParserErrorFieldCallback = Ptr BuildableParseContext -> Ptr GError -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BuildableParserErrorFieldCallback :: BuildableParserErrorFieldCallback -> BuildableParserErrorFieldCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_BuildableParserErrorFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserErrorFieldCallback -> BuildableParseContext -> GError -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_BuildableParserErrorFieldCallback :: MonadIO m => BuildableParserErrorFieldCallback -> m (GClosure C_BuildableParserErrorFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_BuildableParserErrorFieldCallback</a>.
mk_BuildableParserErrorFieldCallback :: C_BuildableParserErrorFieldCallback -> IO (FunPtr C_BuildableParserErrorFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserErrorFieldCallback</a></tt>.
noBuildableParserErrorFieldCallback :: Maybe BuildableParserErrorFieldCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserErrorFieldCallback_WithClosures</a></tt>.
noBuildableParserErrorFieldCallback_WithClosures :: Maybe BuildableParserErrorFieldCallback_WithClosures

-- | Wrap a <a>BuildableParserErrorFieldCallback</a> into a
--   <a>C_BuildableParserErrorFieldCallback</a>.
wrap_BuildableParserErrorFieldCallback :: Maybe (Ptr (FunPtr C_BuildableParserErrorFieldCallback)) -> BuildableParserErrorFieldCallback_WithClosures -> C_BuildableParserErrorFieldCallback

-- | <i>No description available in the introspection data.</i>
type BuildableParserStartElementFieldCallback = BuildableParseContext -> Text -> Text -> Text -> IO ()

-- | <i>No description available in the introspection data.</i>
type BuildableParserStartElementFieldCallback_WithClosures = BuildableParseContext -> Text -> Text -> Text -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_BuildableParserStartElementFieldCallback = Ptr BuildableParseContext -> CString -> CString -> CString -> Ptr () -> Ptr Ptr GError -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BuildableParserStartElementFieldCallback :: BuildableParserStartElementFieldCallback -> BuildableParserStartElementFieldCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_BuildableParserStartElementFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserStartElementFieldCallback -> BuildableParseContext -> Text -> Text -> Text -> Ptr () -> m ()

-- | Generate a function pointer callable from C code, from a
--   <a>C_BuildableParserStartElementFieldCallback</a>.
mk_BuildableParserStartElementFieldCallback :: C_BuildableParserStartElementFieldCallback -> IO (FunPtr C_BuildableParserStartElementFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserStartElementFieldCallback</a></tt>.
noBuildableParserStartElementFieldCallback :: Maybe BuildableParserStartElementFieldCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserStartElementFieldCallback_WithClosures</a></tt>.
noBuildableParserStartElementFieldCallback_WithClosures :: Maybe BuildableParserStartElementFieldCallback_WithClosures

-- | <i>No description available in the introspection data.</i>
type BuildableParserTextFieldCallback = BuildableParseContext -> Text -> CSize -> IO ()

-- | <i>No description available in the introspection data.</i>
type BuildableParserTextFieldCallback_WithClosures = BuildableParseContext -> Text -> CSize -> Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_BuildableParserTextFieldCallback = Ptr BuildableParseContext -> CString -> CSize -> Ptr () -> Ptr Ptr GError -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BuildableParserTextFieldCallback :: BuildableParserTextFieldCallback -> BuildableParserTextFieldCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_BuildableParserTextFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_BuildableParserTextFieldCallback -> BuildableParseContext -> Text -> CSize -> Ptr () -> m ()

-- | Generate a function pointer callable from C code, from a
--   <a>C_BuildableParserTextFieldCallback</a>.
mk_BuildableParserTextFieldCallback :: C_BuildableParserTextFieldCallback -> IO (FunPtr C_BuildableParserTextFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserTextFieldCallback</a></tt>.
noBuildableParserTextFieldCallback :: Maybe BuildableParserTextFieldCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BuildableParserTextFieldCallback_WithClosures</a></tt>.
noBuildableParserTextFieldCallback_WithClosures :: Maybe BuildableParserTextFieldCallback_WithClosures

-- | Type for the callback on the (unwrapped) C side.
type C_CellAllocCallback = Ptr CellRenderer -> Ptr Rectangle -> Ptr Rectangle -> Ptr () -> IO CInt

-- | The type of the callback functions used for iterating over the cell
--   renderers and their allocated areas inside a <tt>GtkCellArea</tt>, see
--   <a>cellAreaForeachAlloc</a>.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type CellAllocCallback = CellRenderer -> Rectangle -> Rectangle -> IO Bool

-- | The type of the callback functions used for iterating over the cell
--   renderers and their allocated areas inside a <tt>GtkCellArea</tt>, see
--   <a>cellAreaForeachAlloc</a>.
type CellAllocCallback_WithClosures = CellRenderer -> Rectangle -> Rectangle -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellAllocCallback :: CellAllocCallback -> CellAllocCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CellAllocCallback :: (HasCallStack, MonadIO m, IsCellRenderer a) => FunPtr C_CellAllocCallback -> a -> Rectangle -> Rectangle -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CellAllocCallback :: MonadIO m => CellAllocCallback -> m (GClosure C_CellAllocCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CellAllocCallback</a>.
mk_CellAllocCallback :: C_CellAllocCallback -> IO (FunPtr C_CellAllocCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellAllocCallback</a></tt>.
noCellAllocCallback :: Maybe CellAllocCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellAllocCallback_WithClosures</a></tt>.
noCellAllocCallback_WithClosures :: Maybe CellAllocCallback_WithClosures

-- | Wrap a <a>CellAllocCallback</a> into a <a>C_CellAllocCallback</a>.
wrap_CellAllocCallback :: Maybe (Ptr (FunPtr C_CellAllocCallback)) -> CellAllocCallback_WithClosures -> C_CellAllocCallback

-- | Type for the callback on the (unwrapped) C side.
type C_CellCallback = Ptr CellRenderer -> Ptr () -> IO CInt

-- | The type of the callback functions used for iterating over the cell
--   renderers of a <tt>GtkCellArea</tt>, see <a>cellAreaForeach</a>.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type CellCallback = CellRenderer -> IO Bool

-- | The type of the callback functions used for iterating over the cell
--   renderers of a <tt>GtkCellArea</tt>, see <a>cellAreaForeach</a>.
type CellCallback_WithClosures = CellRenderer -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellCallback :: CellCallback -> CellCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CellCallback :: (HasCallStack, MonadIO m, IsCellRenderer a) => FunPtr C_CellCallback -> a -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CellCallback :: MonadIO m => CellCallback -> m (GClosure C_CellCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CellCallback</a>.
mk_CellCallback :: C_CellCallback -> IO (FunPtr C_CellCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellCallback</a></tt>.
noCellCallback :: Maybe CellCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellCallback_WithClosures</a></tt>.
noCellCallback_WithClosures :: Maybe CellCallback_WithClosures

-- | Wrap a <a>CellCallback</a> into a <a>C_CellCallback</a>.
wrap_CellCallback :: Maybe (Ptr (FunPtr C_CellCallback)) -> CellCallback_WithClosures -> C_CellCallback

-- | Type for the callback on the (unwrapped) C side.
type C_CellLayoutDataFunc = Ptr CellLayout -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

-- | A function which should set the value of <i><tt>cellLayout</tt></i>’s
--   cell renderer(s) as appropriate.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type CellLayoutDataFunc = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> IO ()

-- | A function which should set the value of <i><tt>cellLayout</tt></i>’s
--   cell renderer(s) as appropriate.
type CellLayoutDataFunc_WithClosures = CellLayout -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CellLayoutDataFunc :: CellLayoutDataFunc -> CellLayoutDataFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CellLayoutDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b, IsTreeModel c) => FunPtr C_CellLayoutDataFunc -> a -> b -> c -> TreeIter -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CellLayoutDataFunc :: MonadIO m => CellLayoutDataFunc -> m (GClosure C_CellLayoutDataFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CellLayoutDataFunc</a>.
mk_CellLayoutDataFunc :: C_CellLayoutDataFunc -> IO (FunPtr C_CellLayoutDataFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellLayoutDataFunc</a></tt>.
noCellLayoutDataFunc :: Maybe CellLayoutDataFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CellLayoutDataFunc_WithClosures</a></tt>.
noCellLayoutDataFunc_WithClosures :: Maybe CellLayoutDataFunc_WithClosures

-- | Wrap a <a>CellLayoutDataFunc</a> into a <a>C_CellLayoutDataFunc</a>.
wrap_CellLayoutDataFunc :: Maybe (Ptr (FunPtr C_CellLayoutDataFunc)) -> CellLayoutDataFunc_WithClosures -> C_CellLayoutDataFunc

-- | Type for the callback on the (unwrapped) C side.
type C_CustomAllocateFunc = Ptr Widget -> Int32 -> Int32 -> Int32 -> IO ()

-- | A function to be used by <tt>GtkCustomLayout</tt> to allocate a
--   widget.
type CustomAllocateFunc = Widget -> Int32 -> Int32 -> Int32 -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CustomAllocateFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_CustomAllocateFunc -> a -> Int32 -> Int32 -> Int32 -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CustomAllocateFunc :: MonadIO m => CustomAllocateFunc -> m (GClosure C_CustomAllocateFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CustomAllocateFunc</a>.
mk_CustomAllocateFunc :: C_CustomAllocateFunc -> IO (FunPtr C_CustomAllocateFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CustomAllocateFunc</a></tt>.
noCustomAllocateFunc :: Maybe CustomAllocateFunc

-- | Wrap a <a>CustomAllocateFunc</a> into a <a>C_CustomAllocateFunc</a>.
wrap_CustomAllocateFunc :: Maybe (Ptr (FunPtr C_CustomAllocateFunc)) -> CustomAllocateFunc -> C_CustomAllocateFunc

-- | Type for the callback on the (unwrapped) C side.
type C_CustomFilterFunc = Ptr Object -> Ptr () -> IO CInt

-- | User function that is called to determine if the <i><tt>item</tt></i>
--   should be matched.
--   
--   If the filter matches the item, this function must return true. If the
--   item should be filtered out, false must be returned.
type CustomFilterFunc = Object -> IO Bool

-- | User function that is called to determine if the <i><tt>item</tt></i>
--   should be matched.
--   
--   If the filter matches the item, this function must return true. If the
--   item should be filtered out, false must be returned.
type CustomFilterFunc_WithClosures = Object -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CustomFilterFunc :: CustomFilterFunc -> CustomFilterFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CustomFilterFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_CustomFilterFunc -> a -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CustomFilterFunc :: MonadIO m => CustomFilterFunc -> m (GClosure C_CustomFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CustomFilterFunc</a>.
mk_CustomFilterFunc :: C_CustomFilterFunc -> IO (FunPtr C_CustomFilterFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CustomFilterFunc</a></tt>.
noCustomFilterFunc :: Maybe CustomFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CustomFilterFunc_WithClosures</a></tt>.
noCustomFilterFunc_WithClosures :: Maybe CustomFilterFunc_WithClosures

-- | Wrap a <a>CustomFilterFunc</a> into a <a>C_CustomFilterFunc</a>.
wrap_CustomFilterFunc :: Maybe (Ptr (FunPtr C_CustomFilterFunc)) -> CustomFilterFunc_WithClosures -> C_CustomFilterFunc

-- | Type for the callback on the (unwrapped) C side.
type C_CustomMeasureFunc = Ptr Widget -> CUInt -> Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

-- | A function to be used by <tt>GtkCustomLayout</tt> to measure a widget.
type CustomMeasureFunc = Widget -> Orientation -> Int32 -> IO (Int32, Int32, Int32, Int32)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CustomMeasureFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_CustomMeasureFunc -> a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CustomMeasureFunc :: MonadIO m => CustomMeasureFunc -> m (GClosure C_CustomMeasureFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CustomMeasureFunc</a>.
mk_CustomMeasureFunc :: C_CustomMeasureFunc -> IO (FunPtr C_CustomMeasureFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CustomMeasureFunc</a></tt>.
noCustomMeasureFunc :: Maybe CustomMeasureFunc

-- | Wrap a <a>CustomMeasureFunc</a> into a <a>C_CustomMeasureFunc</a>.
wrap_CustomMeasureFunc :: Maybe (Ptr (FunPtr C_CustomMeasureFunc)) -> CustomMeasureFunc -> C_CustomMeasureFunc

-- | Type for the callback on the (unwrapped) C side.
type C_CustomRequestModeFunc = Ptr Widget -> IO CUInt

-- | Queries a widget for its preferred size request mode.
type CustomRequestModeFunc = Widget -> IO SizeRequestMode

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CustomRequestModeFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_CustomRequestModeFunc -> a -> m SizeRequestMode

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CustomRequestModeFunc :: MonadIO m => CustomRequestModeFunc -> m (GClosure C_CustomRequestModeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CustomRequestModeFunc</a>.
mk_CustomRequestModeFunc :: C_CustomRequestModeFunc -> IO (FunPtr C_CustomRequestModeFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CustomRequestModeFunc</a></tt>.
noCustomRequestModeFunc :: Maybe CustomRequestModeFunc

-- | Wrap a <a>CustomRequestModeFunc</a> into a
--   <a>C_CustomRequestModeFunc</a>.
wrap_CustomRequestModeFunc :: Maybe (Ptr (FunPtr C_CustomRequestModeFunc)) -> CustomRequestModeFunc -> C_CustomRequestModeFunc

-- | Type for the callback on the (unwrapped) C side.
type C_DrawingAreaDrawFunc = Ptr DrawingArea -> Ptr Context -> Int32 -> Int32 -> Ptr () -> IO ()

-- | Whenever <i><tt>drawingArea</tt></i> needs to redraw, this function
--   will be called.
--   
--   This function should exclusively redraw the contents of the drawing
--   area and must not call any widget functions that cause changes.
type DrawingAreaDrawFunc = DrawingArea -> Context -> Int32 -> Int32 -> IO ()

-- | Whenever <i><tt>drawingArea</tt></i> needs to redraw, this function
--   will be called.
--   
--   This function should exclusively redraw the contents of the drawing
--   area and must not call any widget functions that cause changes.
type DrawingAreaDrawFunc_WithClosures = DrawingArea -> Context -> Int32 -> Int32 -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DrawingAreaDrawFunc :: DrawingAreaDrawFunc -> DrawingAreaDrawFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DrawingAreaDrawFunc :: (HasCallStack, MonadIO m, IsDrawingArea a) => FunPtr C_DrawingAreaDrawFunc -> a -> Context -> Int32 -> Int32 -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DrawingAreaDrawFunc :: MonadIO m => DrawingAreaDrawFunc -> m (GClosure C_DrawingAreaDrawFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DrawingAreaDrawFunc</a>.
mk_DrawingAreaDrawFunc :: C_DrawingAreaDrawFunc -> IO (FunPtr C_DrawingAreaDrawFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DrawingAreaDrawFunc</a></tt>.
noDrawingAreaDrawFunc :: Maybe DrawingAreaDrawFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DrawingAreaDrawFunc_WithClosures</a></tt>.
noDrawingAreaDrawFunc_WithClosures :: Maybe DrawingAreaDrawFunc_WithClosures

-- | Wrap a <a>DrawingAreaDrawFunc</a> into a <a>C_DrawingAreaDrawFunc</a>.
wrap_DrawingAreaDrawFunc :: Maybe (Ptr (FunPtr C_DrawingAreaDrawFunc)) -> DrawingAreaDrawFunc_WithClosures -> C_DrawingAreaDrawFunc

-- | Type for the callback on the (unwrapped) C side.
type C_EntryCompletionMatchFunc = Ptr EntryCompletion -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> matches a given <i><tt>key</tt></i>, and should
--   be displayed as a possible completion for <i><tt>key</tt></i>.
--   
--   Note that <i><tt>key</tt></i> is normalized and case-folded (see
--   <a>utf8Normalize</a> and <a>utf8Casefold</a>). If this is not
--   appropriate, match functions have access to the unmodified key via
--   <tt>gtk_editable_get_text (GTK_EDITABLE
--   (gtk_entry_completion_get_entry ()))</tt>.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type EntryCompletionMatchFunc = EntryCompletion -> Text -> TreeIter -> IO Bool

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> matches a given <i><tt>key</tt></i>, and should
--   be displayed as a possible completion for <i><tt>key</tt></i>.
--   
--   Note that <i><tt>key</tt></i> is normalized and case-folded (see
--   <a>utf8Normalize</a> and <a>utf8Casefold</a>). If this is not
--   appropriate, match functions have access to the unmodified key via
--   <tt>gtk_editable_get_text (GTK_EDITABLE
--   (gtk_entry_completion_get_entry ()))</tt>.
type EntryCompletionMatchFunc_WithClosures = EntryCompletion -> Text -> TreeIter -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_EntryCompletionMatchFunc :: EntryCompletionMatchFunc -> EntryCompletionMatchFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_EntryCompletionMatchFunc :: (HasCallStack, MonadIO m, IsEntryCompletion a) => FunPtr C_EntryCompletionMatchFunc -> a -> Text -> TreeIter -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_EntryCompletionMatchFunc :: MonadIO m => EntryCompletionMatchFunc -> m (GClosure C_EntryCompletionMatchFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_EntryCompletionMatchFunc</a>.
mk_EntryCompletionMatchFunc :: C_EntryCompletionMatchFunc -> IO (FunPtr C_EntryCompletionMatchFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>EntryCompletionMatchFunc</a></tt>.
noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>EntryCompletionMatchFunc_WithClosures</a></tt>.
noEntryCompletionMatchFunc_WithClosures :: Maybe EntryCompletionMatchFunc_WithClosures

-- | Wrap a <a>EntryCompletionMatchFunc</a> into a
--   <a>C_EntryCompletionMatchFunc</a>.
wrap_EntryCompletionMatchFunc :: Maybe (Ptr (FunPtr C_EntryCompletionMatchFunc)) -> EntryCompletionMatchFunc_WithClosures -> C_EntryCompletionMatchFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ExpressionNotify = Ptr () -> IO ()

-- | Callback called by <a>expressionWatch</a> when the expression value
--   changes.
type ExpressionNotify = IO ()

-- | Callback called by <a>expressionWatch</a> when the expression value
--   changes.
type ExpressionNotify_WithClosures = Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ExpressionNotify :: ExpressionNotify -> ExpressionNotify_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ExpressionNotify :: (HasCallStack, MonadIO m) => FunPtr C_ExpressionNotify -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ExpressionNotify :: MonadIO m => ExpressionNotify -> m (GClosure C_ExpressionNotify)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ExpressionNotify</a>.
mk_ExpressionNotify :: C_ExpressionNotify -> IO (FunPtr C_ExpressionNotify)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ExpressionNotify</a></tt>.
noExpressionNotify :: Maybe ExpressionNotify

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ExpressionNotify_WithClosures</a></tt>.
noExpressionNotify_WithClosures :: Maybe ExpressionNotify_WithClosures

-- | Wrap a <a>ExpressionNotify</a> into a <a>C_ExpressionNotify</a>.
wrap_ExpressionNotify :: Maybe (Ptr (FunPtr C_ExpressionNotify)) -> ExpressionNotify_WithClosures -> C_ExpressionNotify

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO Ptr Widget

-- | Called for flow boxes that are bound to a <tt>GListModel</tt>.
--   
--   This function is called for each item that gets added to the model.
type FlowBoxCreateWidgetFunc = Object -> IO Widget

-- | Called for flow boxes that are bound to a <tt>GListModel</tt>.
--   
--   This function is called for each item that gets added to the model.
type FlowBoxCreateWidgetFunc_WithClosures = Object -> Ptr () -> IO Widget

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxCreateWidgetFunc :: FlowBoxCreateWidgetFunc -> FlowBoxCreateWidgetFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_FlowBoxCreateWidgetFunc -> a -> Ptr () -> m Widget

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxCreateWidgetFunc :: MonadIO m => FlowBoxCreateWidgetFunc -> m (GClosure C_FlowBoxCreateWidgetFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxCreateWidgetFunc</a>.
mk_FlowBoxCreateWidgetFunc :: C_FlowBoxCreateWidgetFunc -> IO (FunPtr C_FlowBoxCreateWidgetFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxCreateWidgetFunc</a></tt>.
noFlowBoxCreateWidgetFunc :: Maybe FlowBoxCreateWidgetFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxCreateWidgetFunc_WithClosures</a></tt>.
noFlowBoxCreateWidgetFunc_WithClosures :: Maybe FlowBoxCreateWidgetFunc_WithClosures

-- | Wrap a <a>FlowBoxCreateWidgetFunc</a> into a
--   <a>C_FlowBoxCreateWidgetFunc</a>.
wrap_FlowBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_FlowBoxCreateWidgetFunc)) -> FlowBoxCreateWidgetFunc_WithClosures -> C_FlowBoxCreateWidgetFunc

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxFilterFunc = Ptr FlowBoxChild -> Ptr () -> IO CInt

-- | A function that will be called whenever a child changes or is added.
--   
--   It lets you control if the child should be visible or not.
type FlowBoxFilterFunc = FlowBoxChild -> IO Bool

-- | A function that will be called whenever a child changes or is added.
--   
--   It lets you control if the child should be visible or not.
type FlowBoxFilterFunc_WithClosures = FlowBoxChild -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxFilterFunc :: FlowBoxFilterFunc -> FlowBoxFilterFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxFilterFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => FunPtr C_FlowBoxFilterFunc -> a -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxFilterFunc :: MonadIO m => FlowBoxFilterFunc -> m (GClosure C_FlowBoxFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxFilterFunc</a>.
mk_FlowBoxFilterFunc :: C_FlowBoxFilterFunc -> IO (FunPtr C_FlowBoxFilterFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxFilterFunc</a></tt>.
noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxFilterFunc_WithClosures</a></tt>.
noFlowBoxFilterFunc_WithClosures :: Maybe FlowBoxFilterFunc_WithClosures

-- | Wrap a <a>FlowBoxFilterFunc</a> into a <a>C_FlowBoxFilterFunc</a>.
wrap_FlowBoxFilterFunc :: Maybe (Ptr (FunPtr C_FlowBoxFilterFunc)) -> FlowBoxFilterFunc_WithClosures -> C_FlowBoxFilterFunc

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxForeachFunc = Ptr FlowBox -> Ptr FlowBoxChild -> Ptr () -> IO ()

-- | A function used by <a>flowBoxSelectedForeach</a>.
--   
--   It will be called on every selected child of the <i><tt>box</tt></i>.
type FlowBoxForeachFunc = FlowBox -> FlowBoxChild -> IO ()

-- | A function used by <a>flowBoxSelectedForeach</a>.
--   
--   It will be called on every selected child of the <i><tt>box</tt></i>.
type FlowBoxForeachFunc_WithClosures = FlowBox -> FlowBoxChild -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxForeachFunc :: FlowBoxForeachFunc -> FlowBoxForeachFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxForeachFunc :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => FunPtr C_FlowBoxForeachFunc -> a -> b -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxForeachFunc :: MonadIO m => FlowBoxForeachFunc -> m (GClosure C_FlowBoxForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxForeachFunc</a>.
mk_FlowBoxForeachFunc :: C_FlowBoxForeachFunc -> IO (FunPtr C_FlowBoxForeachFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxForeachFunc</a></tt>.
noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxForeachFunc_WithClosures</a></tt>.
noFlowBoxForeachFunc_WithClosures :: Maybe FlowBoxForeachFunc_WithClosures

-- | Wrap a <a>FlowBoxForeachFunc</a> into a <a>C_FlowBoxForeachFunc</a>.
wrap_FlowBoxForeachFunc :: Maybe (Ptr (FunPtr C_FlowBoxForeachFunc)) -> FlowBoxForeachFunc_WithClosures -> C_FlowBoxForeachFunc

-- | Type for the callback on the (unwrapped) C side.
type C_FlowBoxSortFunc = Ptr FlowBoxChild -> Ptr FlowBoxChild -> Ptr () -> IO Int32

-- | A function to compare two children to determine which should come
--   first.
type FlowBoxSortFunc = FlowBoxChild -> FlowBoxChild -> IO Int32

-- | A function to compare two children to determine which should come
--   first.
type FlowBoxSortFunc_WithClosures = FlowBoxChild -> FlowBoxChild -> Ptr () -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FlowBoxSortFunc :: FlowBoxSortFunc -> FlowBoxSortFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FlowBoxSortFunc :: (HasCallStack, MonadIO m, IsFlowBoxChild a, IsFlowBoxChild b) => FunPtr C_FlowBoxSortFunc -> a -> b -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FlowBoxSortFunc :: MonadIO m => FlowBoxSortFunc -> m (GClosure C_FlowBoxSortFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FlowBoxSortFunc</a>.
mk_FlowBoxSortFunc :: C_FlowBoxSortFunc -> IO (FunPtr C_FlowBoxSortFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxSortFunc</a></tt>.
noFlowBoxSortFunc :: Maybe FlowBoxSortFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FlowBoxSortFunc_WithClosures</a></tt>.
noFlowBoxSortFunc_WithClosures :: Maybe FlowBoxSortFunc_WithClosures

-- | Wrap a <a>FlowBoxSortFunc</a> into a <a>C_FlowBoxSortFunc</a>.
wrap_FlowBoxSortFunc :: Maybe (Ptr (FunPtr C_FlowBoxSortFunc)) -> FlowBoxSortFunc_WithClosures -> C_FlowBoxSortFunc

-- | Type for the callback on the (unwrapped) C side.
type C_FontFilterFunc = Ptr FontFamily -> Ptr FontFace -> Ptr () -> IO CInt

-- | The type of function that is used for deciding what fonts get shown in
--   a <tt>GtkFontChooser</tt>.
--   
--   See <a>fontChooserSetFilterFunc</a>.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type FontFilterFunc = FontFamily -> FontFace -> IO Bool

-- | The type of function that is used for deciding what fonts get shown in
--   a <tt>GtkFontChooser</tt>.
--   
--   See <a>fontChooserSetFilterFunc</a>.
type FontFilterFunc_WithClosures = FontFamily -> FontFace -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FontFilterFunc :: FontFilterFunc -> FontFilterFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FontFilterFunc :: (HasCallStack, MonadIO m, IsFontFamily a, IsFontFace b) => FunPtr C_FontFilterFunc -> a -> b -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FontFilterFunc :: MonadIO m => FontFilterFunc -> m (GClosure C_FontFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FontFilterFunc</a>.
mk_FontFilterFunc :: C_FontFilterFunc -> IO (FunPtr C_FontFilterFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FontFilterFunc</a></tt>.
noFontFilterFunc :: Maybe FontFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FontFilterFunc_WithClosures</a></tt>.
noFontFilterFunc_WithClosures :: Maybe FontFilterFunc_WithClosures

-- | Wrap a <a>FontFilterFunc</a> into a <a>C_FontFilterFunc</a>.
wrap_FontFilterFunc :: Maybe (Ptr (FunPtr C_FontFilterFunc)) -> FontFilterFunc_WithClosures -> C_FontFilterFunc

-- | Type for the callback on the (unwrapped) C side.
type C_IconViewForeachFunc = Ptr IconView -> Ptr TreePath -> Ptr () -> IO ()

-- | A function used by <a>iconViewSelectedForeach</a> to map all selected
--   rows.
--   
--   It will be called on every selected row in the view.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
type IconViewForeachFunc = IconView -> TreePath -> IO ()

-- | A function used by <a>iconViewSelectedForeach</a> to map all selected
--   rows.
--   
--   It will be called on every selected row in the view.
type IconViewForeachFunc_WithClosures = IconView -> TreePath -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_IconViewForeachFunc :: IconViewForeachFunc -> IconViewForeachFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_IconViewForeachFunc :: (HasCallStack, MonadIO m, IsIconView a) => FunPtr C_IconViewForeachFunc -> a -> TreePath -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_IconViewForeachFunc :: MonadIO m => IconViewForeachFunc -> m (GClosure C_IconViewForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_IconViewForeachFunc</a>.
mk_IconViewForeachFunc :: C_IconViewForeachFunc -> IO (FunPtr C_IconViewForeachFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>IconViewForeachFunc</a></tt>.
noIconViewForeachFunc :: Maybe IconViewForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>IconViewForeachFunc_WithClosures</a></tt>.
noIconViewForeachFunc_WithClosures :: Maybe IconViewForeachFunc_WithClosures

-- | Wrap a <a>IconViewForeachFunc</a> into a <a>C_IconViewForeachFunc</a>.
wrap_IconViewForeachFunc :: Maybe (Ptr (FunPtr C_IconViewForeachFunc)) -> IconViewForeachFunc_WithClosures -> C_IconViewForeachFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxCreateWidgetFunc = Ptr Object -> Ptr () -> IO Ptr Widget

-- | Called for list boxes that are bound to a <tt>GListModel</tt> with
--   <a>listBoxBindModel</a> for each item that gets added to the model.
--   
--   If the widget returned is not a <a>ListBoxRow</a> widget, then the
--   widget will be inserted as the child of an intermediate
--   <a>ListBoxRow</a>.
type ListBoxCreateWidgetFunc = Object -> IO Widget

-- | Called for list boxes that are bound to a <tt>GListModel</tt> with
--   <a>listBoxBindModel</a> for each item that gets added to the model.
--   
--   If the widget returned is not a <a>ListBoxRow</a> widget, then the
--   widget will be inserted as the child of an intermediate
--   <a>ListBoxRow</a>.
type ListBoxCreateWidgetFunc_WithClosures = Object -> Ptr () -> IO Widget

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxCreateWidgetFunc :: ListBoxCreateWidgetFunc -> ListBoxCreateWidgetFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxCreateWidgetFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ListBoxCreateWidgetFunc -> a -> Ptr () -> m Widget

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxCreateWidgetFunc :: MonadIO m => ListBoxCreateWidgetFunc -> m (GClosure C_ListBoxCreateWidgetFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxCreateWidgetFunc</a>.
mk_ListBoxCreateWidgetFunc :: C_ListBoxCreateWidgetFunc -> IO (FunPtr C_ListBoxCreateWidgetFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxCreateWidgetFunc</a></tt>.
noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxCreateWidgetFunc_WithClosures</a></tt>.
noListBoxCreateWidgetFunc_WithClosures :: Maybe ListBoxCreateWidgetFunc_WithClosures

-- | Wrap a <a>ListBoxCreateWidgetFunc</a> into a
--   <a>C_ListBoxCreateWidgetFunc</a>.
wrap_ListBoxCreateWidgetFunc :: Maybe (Ptr (FunPtr C_ListBoxCreateWidgetFunc)) -> ListBoxCreateWidgetFunc_WithClosures -> C_ListBoxCreateWidgetFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxFilterFunc = Ptr ListBoxRow -> Ptr () -> IO CInt

-- | Will be called whenever the row changes or is added and lets you
--   control if the row should be visible or not.
type ListBoxFilterFunc = ListBoxRow -> IO Bool

-- | Will be called whenever the row changes or is added and lets you
--   control if the row should be visible or not.
type ListBoxFilterFunc_WithClosures = ListBoxRow -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxFilterFunc :: ListBoxFilterFunc -> ListBoxFilterFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxFilterFunc :: (HasCallStack, MonadIO m, IsListBoxRow a) => FunPtr C_ListBoxFilterFunc -> a -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxFilterFunc :: MonadIO m => ListBoxFilterFunc -> m (GClosure C_ListBoxFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxFilterFunc</a>.
mk_ListBoxFilterFunc :: C_ListBoxFilterFunc -> IO (FunPtr C_ListBoxFilterFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxFilterFunc</a></tt>.
noListBoxFilterFunc :: Maybe ListBoxFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxFilterFunc_WithClosures</a></tt>.
noListBoxFilterFunc_WithClosures :: Maybe ListBoxFilterFunc_WithClosures

-- | Wrap a <a>ListBoxFilterFunc</a> into a <a>C_ListBoxFilterFunc</a>.
wrap_ListBoxFilterFunc :: Maybe (Ptr (FunPtr C_ListBoxFilterFunc)) -> ListBoxFilterFunc_WithClosures -> C_ListBoxFilterFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxForeachFunc = Ptr ListBox -> Ptr ListBoxRow -> Ptr () -> IO ()

-- | A function used by <a>listBoxSelectedForeach</a>.
--   
--   It will be called on every selected child of the <i><tt>box</tt></i>.
type ListBoxForeachFunc = ListBox -> ListBoxRow -> IO ()

-- | A function used by <a>listBoxSelectedForeach</a>.
--   
--   It will be called on every selected child of the <i><tt>box</tt></i>.
type ListBoxForeachFunc_WithClosures = ListBox -> ListBoxRow -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxForeachFunc :: ListBoxForeachFunc -> ListBoxForeachFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxForeachFunc :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => FunPtr C_ListBoxForeachFunc -> a -> b -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxForeachFunc :: MonadIO m => ListBoxForeachFunc -> m (GClosure C_ListBoxForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxForeachFunc</a>.
mk_ListBoxForeachFunc :: C_ListBoxForeachFunc -> IO (FunPtr C_ListBoxForeachFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxForeachFunc</a></tt>.
noListBoxForeachFunc :: Maybe ListBoxForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxForeachFunc_WithClosures</a></tt>.
noListBoxForeachFunc_WithClosures :: Maybe ListBoxForeachFunc_WithClosures

-- | Wrap a <a>ListBoxForeachFunc</a> into a <a>C_ListBoxForeachFunc</a>.
wrap_ListBoxForeachFunc :: Maybe (Ptr (FunPtr C_ListBoxForeachFunc)) -> ListBoxForeachFunc_WithClosures -> C_ListBoxForeachFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxSortFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO Int32

-- | Compare two rows to determine which should be first.
type ListBoxSortFunc = ListBoxRow -> ListBoxRow -> IO Int32

-- | Compare two rows to determine which should be first.
type ListBoxSortFunc_WithClosures = ListBoxRow -> ListBoxRow -> Ptr () -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxSortFunc :: ListBoxSortFunc -> ListBoxSortFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxSortFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxSortFunc -> a -> b -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxSortFunc :: MonadIO m => ListBoxSortFunc -> m (GClosure C_ListBoxSortFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxSortFunc</a>.
mk_ListBoxSortFunc :: C_ListBoxSortFunc -> IO (FunPtr C_ListBoxSortFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxSortFunc</a></tt>.
noListBoxSortFunc :: Maybe ListBoxSortFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxSortFunc_WithClosures</a></tt>.
noListBoxSortFunc_WithClosures :: Maybe ListBoxSortFunc_WithClosures

-- | Wrap a <a>ListBoxSortFunc</a> into a <a>C_ListBoxSortFunc</a>.
wrap_ListBoxSortFunc :: Maybe (Ptr (FunPtr C_ListBoxSortFunc)) -> ListBoxSortFunc_WithClosures -> C_ListBoxSortFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ListBoxUpdateHeaderFunc = Ptr ListBoxRow -> Ptr ListBoxRow -> Ptr () -> IO ()

-- | Whenever <i><tt>row</tt></i> changes or which row is before
--   <i><tt>row</tt></i> changes this is called, which lets you update the
--   header on <i><tt>row</tt></i>.
--   
--   You may remove or set a new one via <a>listBoxRowSetHeader</a> or just
--   change the state of the current header widget.
type ListBoxUpdateHeaderFunc = ListBoxRow -> Maybe ListBoxRow -> IO ()

-- | Whenever <i><tt>row</tt></i> changes or which row is before
--   <i><tt>row</tt></i> changes this is called, which lets you update the
--   header on <i><tt>row</tt></i>.
--   
--   You may remove or set a new one via <a>listBoxRowSetHeader</a> or just
--   change the state of the current header widget.
type ListBoxUpdateHeaderFunc_WithClosures = ListBoxRow -> Maybe ListBoxRow -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFunc -> ListBoxUpdateHeaderFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ListBoxUpdateHeaderFunc :: (HasCallStack, MonadIO m, IsListBoxRow a, IsListBoxRow b) => FunPtr C_ListBoxUpdateHeaderFunc -> a -> Maybe b -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ListBoxUpdateHeaderFunc :: MonadIO m => ListBoxUpdateHeaderFunc -> m (GClosure C_ListBoxUpdateHeaderFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ListBoxUpdateHeaderFunc</a>.
mk_ListBoxUpdateHeaderFunc :: C_ListBoxUpdateHeaderFunc -> IO (FunPtr C_ListBoxUpdateHeaderFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxUpdateHeaderFunc</a></tt>.
noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ListBoxUpdateHeaderFunc_WithClosures</a></tt>.
noListBoxUpdateHeaderFunc_WithClosures :: Maybe ListBoxUpdateHeaderFunc_WithClosures

-- | Wrap a <a>ListBoxUpdateHeaderFunc</a> into a
--   <a>C_ListBoxUpdateHeaderFunc</a>.
wrap_ListBoxUpdateHeaderFunc :: Maybe (Ptr (FunPtr C_ListBoxUpdateHeaderFunc)) -> ListBoxUpdateHeaderFunc_WithClosures -> C_ListBoxUpdateHeaderFunc

-- | Type for the callback on the (unwrapped) C side.
type C_MapListModelMapFunc = Ptr Object -> Ptr () -> IO Ptr Object

-- | User function that is called to map an <i><tt>item</tt></i> of the
--   original model to an item expected by the map model.
--   
--   The returned items must conform to the item type of the model they are
--   used with.
type MapListModelMapFunc = Object -> IO Object

-- | User function that is called to map an <i><tt>item</tt></i> of the
--   original model to an item expected by the map model.
--   
--   The returned items must conform to the item type of the model they are
--   used with.
type MapListModelMapFunc_WithClosures = Object -> Ptr () -> IO Object

-- | A simple wrapper that ignores the closure arguments.
drop_closures_MapListModelMapFunc :: MapListModelMapFunc -> MapListModelMapFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_MapListModelMapFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_MapListModelMapFunc -> a -> Ptr () -> m Object

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_MapListModelMapFunc :: MonadIO m => MapListModelMapFunc -> m (GClosure C_MapListModelMapFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_MapListModelMapFunc</a>.
mk_MapListModelMapFunc :: C_MapListModelMapFunc -> IO (FunPtr C_MapListModelMapFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>MapListModelMapFunc</a></tt>.
noMapListModelMapFunc :: Maybe MapListModelMapFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>MapListModelMapFunc_WithClosures</a></tt>.
noMapListModelMapFunc_WithClosures :: Maybe MapListModelMapFunc_WithClosures

-- | Wrap a <a>MapListModelMapFunc</a> into a <a>C_MapListModelMapFunc</a>.
wrap_MapListModelMapFunc :: Maybe (Ptr (FunPtr C_MapListModelMapFunc)) -> MapListModelMapFunc_WithClosures -> C_MapListModelMapFunc

-- | Type for the callback on the (unwrapped) C side.
type C_MenuButtonCreatePopupFunc = Ptr MenuButton -> Ptr () -> IO ()

-- | User-provided callback function to create a popup for a
--   <tt>GtkMenuButton</tt> on demand.
--   
--   This function is called when the popup of <i><tt>menuButton</tt></i>
--   is shown, but none has been provided via <a>menuButtonSetPopover</a>
--   or <a>menuButtonSetMenuModel</a>.
type MenuButtonCreatePopupFunc = MenuButton -> IO ()

-- | User-provided callback function to create a popup for a
--   <tt>GtkMenuButton</tt> on demand.
--   
--   This function is called when the popup of <i><tt>menuButton</tt></i>
--   is shown, but none has been provided via <a>menuButtonSetPopover</a>
--   or <a>menuButtonSetMenuModel</a>.
type MenuButtonCreatePopupFunc_WithClosures = MenuButton -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_MenuButtonCreatePopupFunc :: MenuButtonCreatePopupFunc -> MenuButtonCreatePopupFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_MenuButtonCreatePopupFunc :: (HasCallStack, MonadIO m, IsMenuButton a) => FunPtr C_MenuButtonCreatePopupFunc -> a -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_MenuButtonCreatePopupFunc :: MonadIO m => MenuButtonCreatePopupFunc -> m (GClosure C_MenuButtonCreatePopupFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_MenuButtonCreatePopupFunc</a>.
mk_MenuButtonCreatePopupFunc :: C_MenuButtonCreatePopupFunc -> IO (FunPtr C_MenuButtonCreatePopupFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>MenuButtonCreatePopupFunc</a></tt>.
noMenuButtonCreatePopupFunc :: Maybe MenuButtonCreatePopupFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>MenuButtonCreatePopupFunc_WithClosures</a></tt>.
noMenuButtonCreatePopupFunc_WithClosures :: Maybe MenuButtonCreatePopupFunc_WithClosures

-- | Wrap a <a>MenuButtonCreatePopupFunc</a> into a
--   <a>C_MenuButtonCreatePopupFunc</a>.
wrap_MenuButtonCreatePopupFunc :: Maybe (Ptr (FunPtr C_MenuButtonCreatePopupFunc)) -> MenuButtonCreatePopupFunc_WithClosures -> C_MenuButtonCreatePopupFunc

-- | Type for the callback on the (unwrapped) C side.
type C_PageSetupDoneFunc = Ptr PageSetup -> Ptr () -> IO ()

-- | The type of function that is passed to
--   <a>printRunPageSetupDialogAsync</a>.
--   
--   This function will be called when the page setup dialog is dismissed,
--   and also serves as destroy notify for <i><tt>data</tt></i>.
type PageSetupDoneFunc = PageSetup -> IO ()

-- | The type of function that is passed to
--   <a>printRunPageSetupDialogAsync</a>.
--   
--   This function will be called when the page setup dialog is dismissed,
--   and also serves as destroy notify for <i><tt>data</tt></i>.
type PageSetupDoneFunc_WithClosures = PageSetup -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PageSetupDoneFunc :: PageSetupDoneFunc -> PageSetupDoneFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PageSetupDoneFunc :: (HasCallStack, MonadIO m, IsPageSetup a) => FunPtr C_PageSetupDoneFunc -> a -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PageSetupDoneFunc :: MonadIO m => PageSetupDoneFunc -> m (GClosure C_PageSetupDoneFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PageSetupDoneFunc</a>.
mk_PageSetupDoneFunc :: C_PageSetupDoneFunc -> IO (FunPtr C_PageSetupDoneFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PageSetupDoneFunc</a></tt>.
noPageSetupDoneFunc :: Maybe PageSetupDoneFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PageSetupDoneFunc_WithClosures</a></tt>.
noPageSetupDoneFunc_WithClosures :: Maybe PageSetupDoneFunc_WithClosures

-- | Wrap a <a>PageSetupDoneFunc</a> into a <a>C_PageSetupDoneFunc</a>.
wrap_PageSetupDoneFunc :: Maybe (Ptr (FunPtr C_PageSetupDoneFunc)) -> PageSetupDoneFunc_WithClosures -> C_PageSetupDoneFunc

-- | Type for the callback on the (unwrapped) C side.
type C_PrintJobCompleteFunc = Ptr PrintJob -> Ptr () -> Ptr GError -> IO ()

-- | The type of callback that is passed to <a>printJobSend</a>.
--   
--   It is called when the print job has been completely sent.
type PrintJobCompleteFunc = PrintJob -> GError -> IO ()

-- | The type of callback that is passed to <a>printJobSend</a>.
--   
--   It is called when the print job has been completely sent.
type PrintJobCompleteFunc_WithClosures = PrintJob -> Ptr () -> GError -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PrintJobCompleteFunc :: PrintJobCompleteFunc -> PrintJobCompleteFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PrintJobCompleteFunc :: (HasCallStack, MonadIO m, IsPrintJob a) => FunPtr C_PrintJobCompleteFunc -> a -> Ptr () -> GError -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PrintJobCompleteFunc :: MonadIO m => PrintJobCompleteFunc -> m (GClosure C_PrintJobCompleteFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PrintJobCompleteFunc</a>.
mk_PrintJobCompleteFunc :: C_PrintJobCompleteFunc -> IO (FunPtr C_PrintJobCompleteFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrintJobCompleteFunc</a></tt>.
noPrintJobCompleteFunc :: Maybe PrintJobCompleteFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrintJobCompleteFunc_WithClosures</a></tt>.
noPrintJobCompleteFunc_WithClosures :: Maybe PrintJobCompleteFunc_WithClosures

-- | Wrap a <a>PrintJobCompleteFunc</a> into a
--   <a>C_PrintJobCompleteFunc</a>.
wrap_PrintJobCompleteFunc :: Maybe (Ptr (FunPtr C_PrintJobCompleteFunc)) -> PrintJobCompleteFunc_WithClosures -> C_PrintJobCompleteFunc

-- | Type for the callback on the (unwrapped) C side.
type C_PrintSettingsFunc = CString -> CString -> Ptr () -> IO ()

-- | Function called by <a>printSettingsForeach</a> on every key/value pair
--   inside a <a>PrintSettings</a>.
type PrintSettingsFunc = Text -> Text -> IO ()

-- | Function called by <a>printSettingsForeach</a> on every key/value pair
--   inside a <a>PrintSettings</a>.
type PrintSettingsFunc_WithClosures = Text -> Text -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PrintSettingsFunc :: PrintSettingsFunc -> PrintSettingsFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PrintSettingsFunc :: (HasCallStack, MonadIO m) => FunPtr C_PrintSettingsFunc -> Text -> Text -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PrintSettingsFunc :: MonadIO m => PrintSettingsFunc -> m (GClosure C_PrintSettingsFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PrintSettingsFunc</a>.
mk_PrintSettingsFunc :: C_PrintSettingsFunc -> IO (FunPtr C_PrintSettingsFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrintSettingsFunc</a></tt>.
noPrintSettingsFunc :: Maybe PrintSettingsFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrintSettingsFunc_WithClosures</a></tt>.
noPrintSettingsFunc_WithClosures :: Maybe PrintSettingsFunc_WithClosures

-- | Wrap a <a>PrintSettingsFunc</a> into a <a>C_PrintSettingsFunc</a>.
wrap_PrintSettingsFunc :: Maybe (Ptr (FunPtr C_PrintSettingsFunc)) -> PrintSettingsFunc_WithClosures -> C_PrintSettingsFunc

-- | Type for the callback on the (unwrapped) C side.
type C_PrinterFunc = Ptr Printer -> Ptr () -> IO CInt

-- | The type of function passed to <a>enumeratePrinters</a>.
--   
--   Note that you need to ref <i><tt>printer</tt></i>, if you want to keep
--   a reference to it after the function has returned.
type PrinterFunc = Printer -> IO Bool

-- | The type of function passed to <a>enumeratePrinters</a>.
--   
--   Note that you need to ref <i><tt>printer</tt></i>, if you want to keep
--   a reference to it after the function has returned.
type PrinterFunc_WithClosures = Printer -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PrinterFunc :: PrinterFunc -> PrinterFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PrinterFunc :: (HasCallStack, MonadIO m, IsPrinter a) => FunPtr C_PrinterFunc -> a -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PrinterFunc :: MonadIO m => PrinterFunc -> m (GClosure C_PrinterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PrinterFunc</a>.
mk_PrinterFunc :: C_PrinterFunc -> IO (FunPtr C_PrinterFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrinterFunc</a></tt>.
noPrinterFunc :: Maybe PrinterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PrinterFunc_WithClosures</a></tt>.
noPrinterFunc_WithClosures :: Maybe PrinterFunc_WithClosures

-- | Wrap a <a>PrinterFunc</a> into a <a>C_PrinterFunc</a>.
wrap_PrinterFunc :: Maybe (Ptr (FunPtr C_PrinterFunc)) -> PrinterFunc_WithClosures -> C_PrinterFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ScaleFormatValueFunc = Ptr Scale -> CDouble -> Ptr () -> IO CString

-- | Function that formats the value of a scale.
--   
--   See <a>scaleSetFormatValueFunc</a>.
type ScaleFormatValueFunc = Scale -> Double -> IO Text

-- | Function that formats the value of a scale.
--   
--   See <a>scaleSetFormatValueFunc</a>.
type ScaleFormatValueFunc_WithClosures = Scale -> Double -> Ptr () -> IO Text

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ScaleFormatValueFunc :: ScaleFormatValueFunc -> ScaleFormatValueFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ScaleFormatValueFunc :: (HasCallStack, MonadIO m, IsScale a) => FunPtr C_ScaleFormatValueFunc -> a -> Double -> Ptr () -> m Text

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ScaleFormatValueFunc :: MonadIO m => ScaleFormatValueFunc -> m (GClosure C_ScaleFormatValueFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ScaleFormatValueFunc</a>.
mk_ScaleFormatValueFunc :: C_ScaleFormatValueFunc -> IO (FunPtr C_ScaleFormatValueFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ScaleFormatValueFunc</a></tt>.
noScaleFormatValueFunc :: Maybe ScaleFormatValueFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ScaleFormatValueFunc_WithClosures</a></tt>.
noScaleFormatValueFunc_WithClosures :: Maybe ScaleFormatValueFunc_WithClosures

-- | Wrap a <a>ScaleFormatValueFunc</a> into a
--   <a>C_ScaleFormatValueFunc</a>.
wrap_ScaleFormatValueFunc :: Maybe (Ptr (FunPtr C_ScaleFormatValueFunc)) -> ScaleFormatValueFunc_WithClosures -> C_ScaleFormatValueFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ShortcutFunc = Ptr Widget -> Ptr GVariant -> Ptr () -> IO CInt

-- | Type for shortcuts based on user callbacks.
type ShortcutFunc = Widget -> Maybe GVariant -> IO Bool

-- | Type for shortcuts based on user callbacks.
type ShortcutFunc_WithClosures = Widget -> Maybe GVariant -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ShortcutFunc :: ShortcutFunc -> ShortcutFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ShortcutFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_ShortcutFunc -> a -> Maybe GVariant -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ShortcutFunc :: MonadIO m => ShortcutFunc -> m (GClosure C_ShortcutFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ShortcutFunc</a>.
mk_ShortcutFunc :: C_ShortcutFunc -> IO (FunPtr C_ShortcutFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ShortcutFunc</a></tt>.
noShortcutFunc :: Maybe ShortcutFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ShortcutFunc_WithClosures</a></tt>.
noShortcutFunc_WithClosures :: Maybe ShortcutFunc_WithClosures

-- | Wrap a <a>ShortcutFunc</a> into a <a>C_ShortcutFunc</a>.
wrap_ShortcutFunc :: Maybe (Ptr (FunPtr C_ShortcutFunc)) -> ShortcutFunc_WithClosures -> C_ShortcutFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TextBufferCommitNotify = Ptr TextBuffer -> CUInt -> Word32 -> Word32 -> Ptr () -> IO ()

-- | A notification callback used by <a>textBufferAddCommitNotify</a>.
--   
--   You may not modify the <a>TextBuffer</a> from a
--   [callback<i><tt>gtk</tt></i>.TextBufferCommitNotify] callback and that
--   is enforced by the <a>TextBuffer</a> API.
--   
--   <ul>
--   <li><i>callback<i><tt>gtk</tt></i>.TextBufferCommitNotify</i> may be
--   used to be notified about changes to the underlying buffer right
--   before-or-after the changes are committed to the underlying B-Tree.
--   This is useful if you want to observe changes to the buffer without
--   other signal handlers potentially modifying state on the way to the
--   default signal handler.</li>
--   </ul>
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT</tt>, <tt>position</tt> is
--   set to the offset in characters from the start of the buffer where the
--   insertion will occur. <tt>length</tt> is set to the number of
--   characters to be inserted. You may not yet retrieve the text until it
--   has been inserted. You may access the text from
--   <tt>GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT</tt> using
--   <a>textBufferGetSlice</a>.
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT</tt>, <tt>position</tt> is set
--   to offset in characters where the insertion occurred and
--   <tt>length</tt> is set to the number of characters inserted.
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE</tt>, <tt>position</tt> is
--   set to offset in characters where the deletion will occur and
--   <tt>length</tt> is set to the number of characters that will be
--   removed. You may still retrieve the text from this handler using
--   <tt>position</tt> and <tt>length</tt>.
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE</tt>, <tt>length</tt> is set
--   to zero to denote that the delete-range has already been committed to
--   the underlying B-Tree. You may no longer retrieve the text that has
--   been deleted from the <a>TextBuffer</a>.
--   
--   <i>Since: 4.16</i>
type TextBufferCommitNotify = TextBuffer -> [TextBufferNotifyFlags] -> Word32 -> Word32 -> IO ()

-- | A notification callback used by <a>textBufferAddCommitNotify</a>.
--   
--   You may not modify the <a>TextBuffer</a> from a
--   [callback<i><tt>gtk</tt></i>.TextBufferCommitNotify] callback and that
--   is enforced by the <a>TextBuffer</a> API.
--   
--   <ul>
--   <li><i>callback<i><tt>gtk</tt></i>.TextBufferCommitNotify</i> may be
--   used to be notified about changes to the underlying buffer right
--   before-or-after the changes are committed to the underlying B-Tree.
--   This is useful if you want to observe changes to the buffer without
--   other signal handlers potentially modifying state on the way to the
--   default signal handler.</li>
--   </ul>
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT</tt>, <tt>position</tt> is
--   set to the offset in characters from the start of the buffer where the
--   insertion will occur. <tt>length</tt> is set to the number of
--   characters to be inserted. You may not yet retrieve the text until it
--   has been inserted. You may access the text from
--   <tt>GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT</tt> using
--   <a>textBufferGetSlice</a>.
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT</tt>, <tt>position</tt> is set
--   to offset in characters where the insertion occurred and
--   <tt>length</tt> is set to the number of characters inserted.
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE</tt>, <tt>position</tt> is
--   set to offset in characters where the deletion will occur and
--   <tt>length</tt> is set to the number of characters that will be
--   removed. You may still retrieve the text from this handler using
--   <tt>position</tt> and <tt>length</tt>.
--   
--   When <i><tt>flags</tt></i> is
--   <tt>GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE</tt>, <tt>length</tt> is set
--   to zero to denote that the delete-range has already been committed to
--   the underlying B-Tree. You may no longer retrieve the text that has
--   been deleted from the <a>TextBuffer</a>.
--   
--   <i>Since: 4.16</i>
type TextBufferCommitNotify_WithClosures = TextBuffer -> [TextBufferNotifyFlags] -> Word32 -> Word32 -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextBufferCommitNotify :: TextBufferCommitNotify -> TextBufferCommitNotify_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TextBufferCommitNotify :: (HasCallStack, MonadIO m, IsTextBuffer a) => FunPtr C_TextBufferCommitNotify -> a -> [TextBufferNotifyFlags] -> Word32 -> Word32 -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TextBufferCommitNotify :: MonadIO m => TextBufferCommitNotify -> m (GClosure C_TextBufferCommitNotify)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TextBufferCommitNotify</a>.
mk_TextBufferCommitNotify :: C_TextBufferCommitNotify -> IO (FunPtr C_TextBufferCommitNotify)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextBufferCommitNotify</a></tt>.
noTextBufferCommitNotify :: Maybe TextBufferCommitNotify

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextBufferCommitNotify_WithClosures</a></tt>.
noTextBufferCommitNotify_WithClosures :: Maybe TextBufferCommitNotify_WithClosures

-- | Wrap a <a>TextBufferCommitNotify</a> into a
--   <a>C_TextBufferCommitNotify</a>.
wrap_TextBufferCommitNotify :: Maybe (Ptr (FunPtr C_TextBufferCommitNotify)) -> TextBufferCommitNotify_WithClosures -> C_TextBufferCommitNotify

-- | Type for the callback on the (unwrapped) C side.
type C_TextCharPredicate = CInt -> Ptr () -> IO CInt

-- | The predicate function used by <a>textIterForwardFindChar</a> and
--   <a>textIterBackwardFindChar</a>.
type TextCharPredicate = Char -> IO Bool

-- | The predicate function used by <a>textIterForwardFindChar</a> and
--   <a>textIterBackwardFindChar</a>.
type TextCharPredicate_WithClosures = Char -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextCharPredicate :: TextCharPredicate -> TextCharPredicate_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TextCharPredicate :: (HasCallStack, MonadIO m) => FunPtr C_TextCharPredicate -> Char -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TextCharPredicate :: MonadIO m => TextCharPredicate -> m (GClosure C_TextCharPredicate)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TextCharPredicate</a>.
mk_TextCharPredicate :: C_TextCharPredicate -> IO (FunPtr C_TextCharPredicate)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextCharPredicate</a></tt>.
noTextCharPredicate :: Maybe TextCharPredicate

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextCharPredicate_WithClosures</a></tt>.
noTextCharPredicate_WithClosures :: Maybe TextCharPredicate_WithClosures

-- | Wrap a <a>TextCharPredicate</a> into a <a>C_TextCharPredicate</a>.
wrap_TextCharPredicate :: Maybe (Ptr (FunPtr C_TextCharPredicate)) -> TextCharPredicate_WithClosures -> C_TextCharPredicate

-- | Type for the callback on the (unwrapped) C side.
type C_TextTagTableForeach = Ptr TextTag -> Ptr () -> IO ()

-- | A function used with <a>textTagTableForeach</a>, to iterate over every
--   <tt>GtkTextTag</tt> inside a <tt>GtkTextTagTable</tt>.
type TextTagTableForeach = TextTag -> IO ()

-- | A function used with <a>textTagTableForeach</a>, to iterate over every
--   <tt>GtkTextTag</tt> inside a <tt>GtkTextTagTable</tt>.
type TextTagTableForeach_WithClosures = TextTag -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TextTagTableForeach :: TextTagTableForeach -> TextTagTableForeach_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TextTagTableForeach :: (HasCallStack, MonadIO m, IsTextTag a) => FunPtr C_TextTagTableForeach -> a -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TextTagTableForeach :: MonadIO m => TextTagTableForeach -> m (GClosure C_TextTagTableForeach)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TextTagTableForeach</a>.
mk_TextTagTableForeach :: C_TextTagTableForeach -> IO (FunPtr C_TextTagTableForeach)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextTagTableForeach</a></tt>.
noTextTagTableForeach :: Maybe TextTagTableForeach

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TextTagTableForeach_WithClosures</a></tt>.
noTextTagTableForeach_WithClosures :: Maybe TextTagTableForeach_WithClosures

-- | Wrap a <a>TextTagTableForeach</a> into a <a>C_TextTagTableForeach</a>.
wrap_TextTagTableForeach :: Maybe (Ptr (FunPtr C_TextTagTableForeach)) -> TextTagTableForeach_WithClosures -> C_TextTagTableForeach

-- | Type for the callback on the (unwrapped) C side.
type C_TickCallback = Ptr Widget -> Ptr FrameClock -> Ptr () -> IO CInt

-- | Callback type for adding a function to update animations.
--   
--   See <a>widgetAddTickCallback</a>.
type TickCallback = Widget -> FrameClock -> IO Bool

-- | Callback type for adding a function to update animations.
--   
--   See <a>widgetAddTickCallback</a>.
type TickCallback_WithClosures = Widget -> FrameClock -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TickCallback :: TickCallback -> TickCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TickCallback :: (HasCallStack, MonadIO m, IsWidget a, IsFrameClock b) => FunPtr C_TickCallback -> a -> b -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TickCallback :: MonadIO m => TickCallback -> m (GClosure C_TickCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TickCallback</a>.
mk_TickCallback :: C_TickCallback -> IO (FunPtr C_TickCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TickCallback</a></tt>.
noTickCallback :: Maybe TickCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TickCallback_WithClosures</a></tt>.
noTickCallback_WithClosures :: Maybe TickCallback_WithClosures

-- | Wrap a <a>TickCallback</a> into a <a>C_TickCallback</a>.
wrap_TickCallback :: Maybe (Ptr (FunPtr C_TickCallback)) -> TickCallback_WithClosures -> C_TickCallback

-- | Type for the callback on the (unwrapped) C side.
type C_TreeCellDataFunc = Ptr TreeViewColumn -> Ptr CellRenderer -> Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO ()

-- | A function to set the properties of a cell instead of just using the
--   straight mapping between the cell and the model.
--   
--   This function is useful for customizing the cell renderer. For
--   example, a function might get an* integer from the
--   <i><tt>treeModel</tt></i>, and render it to the “text” attribute of
--   “cell” by converting it to its written equivalent.
--   
--   See also: <a>treeViewColumnSetCellDataFunc</a>

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type TreeCellDataFunc = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> IO ()

-- | A function to set the properties of a cell instead of just using the
--   straight mapping between the cell and the model.
--   
--   This function is useful for customizing the cell renderer. For
--   example, a function might get an* integer from the
--   <i><tt>treeModel</tt></i>, and render it to the “text” attribute of
--   “cell” by converting it to its written equivalent.
--   
--   See also: <a>treeViewColumnSetCellDataFunc</a>
type TreeCellDataFunc_WithClosures = TreeViewColumn -> CellRenderer -> TreeModel -> TreeIter -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeCellDataFunc :: TreeCellDataFunc -> TreeCellDataFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeCellDataFunc :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b, IsTreeModel c) => FunPtr C_TreeCellDataFunc -> a -> b -> c -> TreeIter -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeCellDataFunc :: MonadIO m => TreeCellDataFunc -> m (GClosure C_TreeCellDataFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeCellDataFunc</a>.
mk_TreeCellDataFunc :: C_TreeCellDataFunc -> IO (FunPtr C_TreeCellDataFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeCellDataFunc</a></tt>.
noTreeCellDataFunc :: Maybe TreeCellDataFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeCellDataFunc_WithClosures</a></tt>.
noTreeCellDataFunc_WithClosures :: Maybe TreeCellDataFunc_WithClosures

-- | Wrap a <a>TreeCellDataFunc</a> into a <a>C_TreeCellDataFunc</a>.
wrap_TreeCellDataFunc :: Maybe (Ptr (FunPtr C_TreeCellDataFunc)) -> TreeCellDataFunc_WithClosures -> C_TreeCellDataFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeIterCompareFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr TreeIter -> Ptr () -> IO Int32

-- | A GtkTreeIterCompareFunc should return a negative integer, zero, or a
--   positive integer if <i><tt>a</tt></i> sorts before <i><tt>b</tt></i>,
--   <i><tt>a</tt></i> sorts with <i><tt>b</tt></i>, or <i><tt>a</tt></i>
--   sorts after <i><tt>b</tt></i> respectively.
--   
--   If two iters compare as equal, their order in the sorted model is
--   undefined. In order to ensure that the <tt>GtkTreeSortable</tt>
--   behaves as expected, the GtkTreeIterCompareFunc must define a partial
--   order on the model, i.e. it must be reflexive, antisymmetric and
--   transitive.
--   
--   For example, if <i><tt>model</tt></i> is a product catalogue, then a
--   compare function for the “price” column could be one which returns
--   <tt>price_of(@a) - price_of(@b)</tt>.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type TreeIterCompareFunc = TreeModel -> TreeIter -> TreeIter -> IO Int32

-- | A GtkTreeIterCompareFunc should return a negative integer, zero, or a
--   positive integer if <i><tt>a</tt></i> sorts before <i><tt>b</tt></i>,
--   <i><tt>a</tt></i> sorts with <i><tt>b</tt></i>, or <i><tt>a</tt></i>
--   sorts after <i><tt>b</tt></i> respectively.
--   
--   If two iters compare as equal, their order in the sorted model is
--   undefined. In order to ensure that the <tt>GtkTreeSortable</tt>
--   behaves as expected, the GtkTreeIterCompareFunc must define a partial
--   order on the model, i.e. it must be reflexive, antisymmetric and
--   transitive.
--   
--   For example, if <i><tt>model</tt></i> is a product catalogue, then a
--   compare function for the “price” column could be one which returns
--   <tt>price_of(@a) - price_of(@b)</tt>.
type TreeIterCompareFunc_WithClosures = TreeModel -> TreeIter -> TreeIter -> Ptr () -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeIterCompareFunc :: TreeIterCompareFunc -> TreeIterCompareFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeIterCompareFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeIterCompareFunc -> a -> TreeIter -> TreeIter -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeIterCompareFunc :: MonadIO m => TreeIterCompareFunc -> m (GClosure C_TreeIterCompareFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeIterCompareFunc</a>.
mk_TreeIterCompareFunc :: C_TreeIterCompareFunc -> IO (FunPtr C_TreeIterCompareFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeIterCompareFunc</a></tt>.
noTreeIterCompareFunc :: Maybe TreeIterCompareFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeIterCompareFunc_WithClosures</a></tt>.
noTreeIterCompareFunc_WithClosures :: Maybe TreeIterCompareFunc_WithClosures

-- | Wrap a <a>TreeIterCompareFunc</a> into a <a>C_TreeIterCompareFunc</a>.
wrap_TreeIterCompareFunc :: Maybe (Ptr (FunPtr C_TreeIterCompareFunc)) -> TreeIterCompareFunc_WithClosures -> C_TreeIterCompareFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeListModelCreateModelFunc = Ptr Object -> Ptr () -> IO Ptr ListModel

-- | Prototype of the function called to create new child models when
--   <a>treeListRowSetExpanded</a> is called.
--   
--   This function can return <a>Nothing</a> to indicate that
--   <i><tt>item</tt></i> is guaranteed to be a leaf node and will never
--   have children. If it does not have children but may get children
--   later, it should return an empty model that is filled once children
--   arrive.
type TreeListModelCreateModelFunc = Object -> IO Maybe ListModel

-- | Prototype of the function called to create new child models when
--   <a>treeListRowSetExpanded</a> is called.
--   
--   This function can return <a>Nothing</a> to indicate that
--   <i><tt>item</tt></i> is guaranteed to be a leaf node and will never
--   have children. If it does not have children but may get children
--   later, it should return an empty model that is filled once children
--   arrive.
type TreeListModelCreateModelFunc_WithClosures = Object -> Ptr () -> IO Maybe ListModel

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeListModelCreateModelFunc :: TreeListModelCreateModelFunc -> TreeListModelCreateModelFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeListModelCreateModelFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_TreeListModelCreateModelFunc -> a -> Ptr () -> m (Maybe ListModel)

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeListModelCreateModelFunc :: MonadIO m => TreeListModelCreateModelFunc -> m (GClosure C_TreeListModelCreateModelFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeListModelCreateModelFunc</a>.
mk_TreeListModelCreateModelFunc :: C_TreeListModelCreateModelFunc -> IO (FunPtr C_TreeListModelCreateModelFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeListModelCreateModelFunc</a></tt>.
noTreeListModelCreateModelFunc :: Maybe TreeListModelCreateModelFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeListModelCreateModelFunc_WithClosures</a></tt>.
noTreeListModelCreateModelFunc_WithClosures :: Maybe TreeListModelCreateModelFunc_WithClosures

-- | Wrap a <a>TreeListModelCreateModelFunc</a> into a
--   <a>C_TreeListModelCreateModelFunc</a>.
wrap_TreeListModelCreateModelFunc :: Maybe (Ptr (FunPtr C_TreeListModelCreateModelFunc)) -> TreeListModelCreateModelFunc_WithClosures -> C_TreeListModelCreateModelFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeModelFilterModifyFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr GValue -> Int32 -> Ptr () -> IO ()

-- | A function which calculates display values from raw values in the
--   model. It must fill <i><tt>value</tt></i> with the display value for
--   the column <i><tt>column</tt></i> in the row indicated by
--   <i><tt>iter</tt></i>.
--   
--   Since this function is called for each data access, it’s not a
--   particularly efficient operation.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type TreeModelFilterModifyFunc = TreeModel -> TreeIter -> GValue -> Int32 -> IO ()

-- | A function which calculates display values from raw values in the
--   model. It must fill <i><tt>value</tt></i> with the display value for
--   the column <i><tt>column</tt></i> in the row indicated by
--   <i><tt>iter</tt></i>.
--   
--   Since this function is called for each data access, it’s not a
--   particularly efficient operation.
type TreeModelFilterModifyFunc_WithClosures = TreeModel -> TreeIter -> GValue -> Int32 -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelFilterModifyFunc :: TreeModelFilterModifyFunc -> TreeModelFilterModifyFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeModelFilterModifyFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterModifyFunc -> a -> TreeIter -> GValue -> Int32 -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeModelFilterModifyFunc :: MonadIO m => TreeModelFilterModifyFunc -> m (GClosure C_TreeModelFilterModifyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeModelFilterModifyFunc</a>.
mk_TreeModelFilterModifyFunc :: C_TreeModelFilterModifyFunc -> IO (FunPtr C_TreeModelFilterModifyFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterModifyFunc</a></tt>.
noTreeModelFilterModifyFunc :: Maybe TreeModelFilterModifyFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterModifyFunc_WithClosures</a></tt>.
noTreeModelFilterModifyFunc_WithClosures :: Maybe TreeModelFilterModifyFunc_WithClosures

-- | Wrap a <a>TreeModelFilterModifyFunc</a> into a
--   <a>C_TreeModelFilterModifyFunc</a>.
wrap_TreeModelFilterModifyFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterModifyFunc)) -> TreeModelFilterModifyFunc_WithClosures -> C_TreeModelFilterModifyFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeModelFilterVisibleFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> is visible.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type TreeModelFilterVisibleFunc = TreeModel -> TreeIter -> IO Bool

-- | A function which decides whether the row indicated by
--   <i><tt>iter</tt></i> is visible.
type TreeModelFilterVisibleFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelFilterVisibleFunc :: TreeModelFilterVisibleFunc -> TreeModelFilterVisibleFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeModelFilterVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelFilterVisibleFunc -> a -> TreeIter -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeModelFilterVisibleFunc :: MonadIO m => TreeModelFilterVisibleFunc -> m (GClosure C_TreeModelFilterVisibleFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeModelFilterVisibleFunc</a>.
mk_TreeModelFilterVisibleFunc :: C_TreeModelFilterVisibleFunc -> IO (FunPtr C_TreeModelFilterVisibleFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterVisibleFunc</a></tt>.
noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelFilterVisibleFunc_WithClosures</a></tt>.
noTreeModelFilterVisibleFunc_WithClosures :: Maybe TreeModelFilterVisibleFunc_WithClosures

-- | Wrap a <a>TreeModelFilterVisibleFunc</a> into a
--   <a>C_TreeModelFilterVisibleFunc</a>.
wrap_TreeModelFilterVisibleFunc :: Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc)) -> TreeModelFilterVisibleFunc_WithClosures -> C_TreeModelFilterVisibleFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeModelForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO CInt

-- | Type of the callback passed to <a>treeModelForeach</a> to iterate over
--   the rows in a tree model.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
type TreeModelForeachFunc = TreeModel -> TreePath -> TreeIter -> IO Bool

-- | Type of the callback passed to <a>treeModelForeach</a> to iterate over
--   the rows in a tree model.
type TreeModelForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeModelForeachFunc :: TreeModelForeachFunc -> TreeModelForeachFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeModelForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeModelForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeModelForeachFunc :: MonadIO m => TreeModelForeachFunc -> m (GClosure C_TreeModelForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeModelForeachFunc</a>.
mk_TreeModelForeachFunc :: C_TreeModelForeachFunc -> IO (FunPtr C_TreeModelForeachFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelForeachFunc</a></tt>.
noTreeModelForeachFunc :: Maybe TreeModelForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeModelForeachFunc_WithClosures</a></tt>.
noTreeModelForeachFunc_WithClosures :: Maybe TreeModelForeachFunc_WithClosures

-- | Wrap a <a>TreeModelForeachFunc</a> into a
--   <a>C_TreeModelForeachFunc</a>.
wrap_TreeModelForeachFunc :: Maybe (Ptr (FunPtr C_TreeModelForeachFunc)) -> TreeModelForeachFunc_WithClosures -> C_TreeModelForeachFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeSelectionForeachFunc = Ptr TreeModel -> Ptr TreePath -> Ptr TreeIter -> Ptr () -> IO ()

-- | A function used by <a>treeSelectionSelectedForeach</a> to map all
--   selected rows. It will be called on every selected row in the view.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type TreeSelectionForeachFunc = TreeModel -> TreePath -> TreeIter -> IO ()

-- | A function used by <a>treeSelectionSelectedForeach</a> to map all
--   selected rows. It will be called on every selected row in the view.
type TreeSelectionForeachFunc_WithClosures = TreeModel -> TreePath -> TreeIter -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeSelectionForeachFunc :: TreeSelectionForeachFunc -> TreeSelectionForeachFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeSelectionForeachFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeSelectionForeachFunc -> a -> TreePath -> TreeIter -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeSelectionForeachFunc :: MonadIO m => TreeSelectionForeachFunc -> m (GClosure C_TreeSelectionForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeSelectionForeachFunc</a>.
mk_TreeSelectionForeachFunc :: C_TreeSelectionForeachFunc -> IO (FunPtr C_TreeSelectionForeachFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionForeachFunc</a></tt>.
noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionForeachFunc_WithClosures</a></tt>.
noTreeSelectionForeachFunc_WithClosures :: Maybe TreeSelectionForeachFunc_WithClosures

-- | Wrap a <a>TreeSelectionForeachFunc</a> into a
--   <a>C_TreeSelectionForeachFunc</a>.
wrap_TreeSelectionForeachFunc :: Maybe (Ptr (FunPtr C_TreeSelectionForeachFunc)) -> TreeSelectionForeachFunc_WithClosures -> C_TreeSelectionForeachFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeSelectionFunc = Ptr TreeSelection -> Ptr TreeModel -> Ptr TreePath -> CInt -> Ptr () -> IO CInt

-- | A function used by <a>treeSelectionSetSelectFunction</a> to filter
--   whether or not a row may be selected. It is called whenever a row's
--   state might change.
--   
--   A return value of <a>True</a> indicates to <i><tt>selection</tt></i>
--   that it is okay to change the selection.

-- | <i>Deprecated: (Since version 4.20)There is no replacement</i>
type TreeSelectionFunc = TreeSelection -> TreeModel -> TreePath -> Bool -> IO Bool

-- | A function used by <a>treeSelectionSetSelectFunction</a> to filter
--   whether or not a row may be selected. It is called whenever a row's
--   state might change.
--   
--   A return value of <a>True</a> indicates to <i><tt>selection</tt></i>
--   that it is okay to change the selection.
type TreeSelectionFunc_WithClosures = TreeSelection -> TreeModel -> TreePath -> Bool -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeSelectionFunc :: TreeSelectionFunc -> TreeSelectionFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeSelectionFunc :: (HasCallStack, MonadIO m, IsTreeSelection a, IsTreeModel b) => FunPtr C_TreeSelectionFunc -> a -> b -> TreePath -> Bool -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeSelectionFunc :: MonadIO m => TreeSelectionFunc -> m (GClosure C_TreeSelectionFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeSelectionFunc</a>.
mk_TreeSelectionFunc :: C_TreeSelectionFunc -> IO (FunPtr C_TreeSelectionFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionFunc</a></tt>.
noTreeSelectionFunc :: Maybe TreeSelectionFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeSelectionFunc_WithClosures</a></tt>.
noTreeSelectionFunc_WithClosures :: Maybe TreeSelectionFunc_WithClosures

-- | Wrap a <a>TreeSelectionFunc</a> into a <a>C_TreeSelectionFunc</a>.
wrap_TreeSelectionFunc :: Maybe (Ptr (FunPtr C_TreeSelectionFunc)) -> TreeSelectionFunc_WithClosures -> C_TreeSelectionFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewColumnDropFunc = Ptr TreeView -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr TreeViewColumn -> Ptr () -> IO CInt

-- | Function type for determining whether <i><tt>column</tt></i> can be
--   dropped in a particular spot (as determined by
--   <i><tt>prevColumn</tt></i> and <i><tt>nextColumn</tt></i>). In left to
--   right locales, <i><tt>prevColumn</tt></i> is on the left of the
--   potential drop spot, and <i><tt>nextColumn</tt></i> is on the right.
--   In right to left mode, this is reversed. This function should return
--   <a>True</a> if the spot is a valid drop spot. Please note that
--   returning <a>True</a> does not actually indicate that the column drop
--   was made, but is meant only to indicate a possible drop spot to the
--   user.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
type TreeViewColumnDropFunc = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> IO Bool

-- | Function type for determining whether <i><tt>column</tt></i> can be
--   dropped in a particular spot (as determined by
--   <i><tt>prevColumn</tt></i> and <i><tt>nextColumn</tt></i>). In left to
--   right locales, <i><tt>prevColumn</tt></i> is on the left of the
--   potential drop spot, and <i><tt>nextColumn</tt></i> is on the right.
--   In right to left mode, this is reversed. This function should return
--   <a>True</a> if the spot is a valid drop spot. Please note that
--   returning <a>True</a> does not actually indicate that the column drop
--   was made, but is meant only to indicate a possible drop spot to the
--   user.
type TreeViewColumnDropFunc_WithClosures = TreeView -> TreeViewColumn -> TreeViewColumn -> TreeViewColumn -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewColumnDropFunc :: TreeViewColumnDropFunc -> TreeViewColumnDropFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewColumnDropFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c, IsTreeViewColumn d) => FunPtr C_TreeViewColumnDropFunc -> a -> b -> c -> d -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewColumnDropFunc :: MonadIO m => TreeViewColumnDropFunc -> m (GClosure C_TreeViewColumnDropFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewColumnDropFunc</a>.
mk_TreeViewColumnDropFunc :: C_TreeViewColumnDropFunc -> IO (FunPtr C_TreeViewColumnDropFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewColumnDropFunc</a></tt>.
noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewColumnDropFunc_WithClosures</a></tt>.
noTreeViewColumnDropFunc_WithClosures :: Maybe TreeViewColumnDropFunc_WithClosures

-- | Wrap a <a>TreeViewColumnDropFunc</a> into a
--   <a>C_TreeViewColumnDropFunc</a>.
wrap_TreeViewColumnDropFunc :: Maybe (Ptr (FunPtr C_TreeViewColumnDropFunc)) -> TreeViewColumnDropFunc_WithClosures -> C_TreeViewColumnDropFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewMappingFunc = Ptr TreeView -> Ptr TreePath -> Ptr () -> IO ()

-- | Function used for <a>treeViewMapExpandedRows</a>.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
type TreeViewMappingFunc = TreeView -> TreePath -> IO ()

-- | Function used for <a>treeViewMapExpandedRows</a>.
type TreeViewMappingFunc_WithClosures = TreeView -> TreePath -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewMappingFunc :: TreeViewMappingFunc -> TreeViewMappingFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewMappingFunc :: (HasCallStack, MonadIO m, IsTreeView a) => FunPtr C_TreeViewMappingFunc -> a -> TreePath -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewMappingFunc :: MonadIO m => TreeViewMappingFunc -> m (GClosure C_TreeViewMappingFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewMappingFunc</a>.
mk_TreeViewMappingFunc :: C_TreeViewMappingFunc -> IO (FunPtr C_TreeViewMappingFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewMappingFunc</a></tt>.
noTreeViewMappingFunc :: Maybe TreeViewMappingFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewMappingFunc_WithClosures</a></tt>.
noTreeViewMappingFunc_WithClosures :: Maybe TreeViewMappingFunc_WithClosures

-- | Wrap a <a>TreeViewMappingFunc</a> into a <a>C_TreeViewMappingFunc</a>.
wrap_TreeViewMappingFunc :: Maybe (Ptr (FunPtr C_TreeViewMappingFunc)) -> TreeViewMappingFunc_WithClosures -> C_TreeViewMappingFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewRowSeparatorFunc = Ptr TreeModel -> Ptr TreeIter -> Ptr () -> IO CInt

-- | Function type for determining whether the row pointed to by
--   <i><tt>iter</tt></i> should be rendered as a separator. A common way
--   to implement this is to have a boolean column in the model, whose
--   values the <tt>GtkTreeViewRowSeparatorFunc</tt> returns.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
type TreeViewRowSeparatorFunc = TreeModel -> TreeIter -> IO Bool

-- | Function type for determining whether the row pointed to by
--   <i><tt>iter</tt></i> should be rendered as a separator. A common way
--   to implement this is to have a boolean column in the model, whose
--   values the <tt>GtkTreeViewRowSeparatorFunc</tt> returns.
type TreeViewRowSeparatorFunc_WithClosures = TreeModel -> TreeIter -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewRowSeparatorFunc :: TreeViewRowSeparatorFunc -> TreeViewRowSeparatorFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewRowSeparatorFunc -> a -> TreeIter -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewRowSeparatorFunc :: MonadIO m => TreeViewRowSeparatorFunc -> m (GClosure C_TreeViewRowSeparatorFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewRowSeparatorFunc</a>.
mk_TreeViewRowSeparatorFunc :: C_TreeViewRowSeparatorFunc -> IO (FunPtr C_TreeViewRowSeparatorFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewRowSeparatorFunc</a></tt>.
noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewRowSeparatorFunc_WithClosures</a></tt>.
noTreeViewRowSeparatorFunc_WithClosures :: Maybe TreeViewRowSeparatorFunc_WithClosures

-- | Wrap a <a>TreeViewRowSeparatorFunc</a> into a
--   <a>C_TreeViewRowSeparatorFunc</a>.
wrap_TreeViewRowSeparatorFunc :: Maybe (Ptr (FunPtr C_TreeViewRowSeparatorFunc)) -> TreeViewRowSeparatorFunc_WithClosures -> C_TreeViewRowSeparatorFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TreeViewSearchEqualFunc = Ptr TreeModel -> Int32 -> CString -> Ptr TreeIter -> Ptr () -> IO CInt

-- | A function used for checking whether a row in <i><tt>model</tt></i>
--   matches a search key string entered by the user. Note the return value
--   is reversed from what you would normally expect, though it has some
--   similarity to <tt><i>strcmp()</i></tt> returning 0 for equal strings.

-- | <i>Deprecated: (Since version 4.20)There is no replacement.</i>
type TreeViewSearchEqualFunc = TreeModel -> Int32 -> Text -> TreeIter -> IO Bool

-- | A function used for checking whether a row in <i><tt>model</tt></i>
--   matches a search key string entered by the user. Note the return value
--   is reversed from what you would normally expect, though it has some
--   similarity to <tt><i>strcmp()</i></tt> returning 0 for equal strings.
type TreeViewSearchEqualFunc_WithClosures = TreeModel -> Int32 -> Text -> TreeIter -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeViewSearchEqualFunc :: TreeViewSearchEqualFunc -> TreeViewSearchEqualFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeViewSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeModel a) => FunPtr C_TreeViewSearchEqualFunc -> a -> Int32 -> Text -> TreeIter -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeViewSearchEqualFunc :: MonadIO m => TreeViewSearchEqualFunc -> m (GClosure C_TreeViewSearchEqualFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeViewSearchEqualFunc</a>.
mk_TreeViewSearchEqualFunc :: C_TreeViewSearchEqualFunc -> IO (FunPtr C_TreeViewSearchEqualFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewSearchEqualFunc</a></tt>.
noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeViewSearchEqualFunc_WithClosures</a></tt>.
noTreeViewSearchEqualFunc_WithClosures :: Maybe TreeViewSearchEqualFunc_WithClosures

-- | Wrap a <a>TreeViewSearchEqualFunc</a> into a
--   <a>C_TreeViewSearchEqualFunc</a>.
wrap_TreeViewSearchEqualFunc :: Maybe (Ptr (FunPtr C_TreeViewSearchEqualFunc)) -> TreeViewSearchEqualFunc_WithClosures -> C_TreeViewSearchEqualFunc

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetActionActivateFunc = Ptr Widget -> CString -> Ptr GVariant -> IO ()

-- | The type of the callback functions used for activating actions
--   installed with <a>widgetClassInstallAction</a>.
--   
--   The <i><tt>parameter</tt></i> must match the
--   <i><tt>parameterType</tt></i> of the action.
type WidgetActionActivateFunc = Widget -> Text -> Maybe GVariant -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetActionActivateFunc :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetActionActivateFunc -> a -> Text -> Maybe GVariant -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetActionActivateFunc :: MonadIO m => WidgetActionActivateFunc -> m (GClosure C_WidgetActionActivateFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetActionActivateFunc</a>.
mk_WidgetActionActivateFunc :: C_WidgetActionActivateFunc -> IO (FunPtr C_WidgetActionActivateFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetActionActivateFunc</a></tt>.
noWidgetActionActivateFunc :: Maybe WidgetActionActivateFunc

-- | Wrap a <a>WidgetActionActivateFunc</a> into a
--   <a>C_WidgetActionActivateFunc</a>.
wrap_WidgetActionActivateFunc :: Maybe (Ptr (FunPtr C_WidgetActionActivateFunc)) -> WidgetActionActivateFunc -> C_WidgetActionActivateFunc

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassComputeExpandFieldCallback = Ptr Widget -> CInt -> CInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassComputeExpandFieldCallback = Widget -> Bool -> Bool -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassComputeExpandFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassComputeExpandFieldCallback -> a -> Bool -> Bool -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassComputeExpandFieldCallback :: MonadIO m => WidgetClassComputeExpandFieldCallback -> m (GClosure C_WidgetClassComputeExpandFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassComputeExpandFieldCallback</a>.
mk_WidgetClassComputeExpandFieldCallback :: C_WidgetClassComputeExpandFieldCallback -> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassComputeExpandFieldCallback</a></tt>.
noWidgetClassComputeExpandFieldCallback :: Maybe WidgetClassComputeExpandFieldCallback

-- | Wrap a <a>WidgetClassComputeExpandFieldCallback</a> into a
--   <a>C_WidgetClassComputeExpandFieldCallback</a>.
wrap_WidgetClassComputeExpandFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)) -> WidgetClassComputeExpandFieldCallback -> C_WidgetClassComputeExpandFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassContainsFieldCallback = Ptr Widget -> CDouble -> CDouble -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassContainsFieldCallback = Widget -> Double -> Double -> IO Bool

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassContainsFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassContainsFieldCallback -> a -> Double -> Double -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassContainsFieldCallback :: MonadIO m => WidgetClassContainsFieldCallback -> m (GClosure C_WidgetClassContainsFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassContainsFieldCallback</a>.
mk_WidgetClassContainsFieldCallback :: C_WidgetClassContainsFieldCallback -> IO (FunPtr C_WidgetClassContainsFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassContainsFieldCallback</a></tt>.
noWidgetClassContainsFieldCallback :: Maybe WidgetClassContainsFieldCallback

-- | Wrap a <a>WidgetClassContainsFieldCallback</a> into a
--   <a>C_WidgetClassContainsFieldCallback</a>.
wrap_WidgetClassContainsFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassContainsFieldCallback)) -> WidgetClassContainsFieldCallback -> C_WidgetClassContainsFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassCssChangedFieldCallback = Ptr Widget -> Ptr CssStyleChange -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassCssChangedFieldCallback = Widget -> CssStyleChange -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassCssChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassCssChangedFieldCallback -> a -> CssStyleChange -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassCssChangedFieldCallback :: MonadIO m => WidgetClassCssChangedFieldCallback -> m (GClosure C_WidgetClassCssChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassCssChangedFieldCallback</a>.
mk_WidgetClassCssChangedFieldCallback :: C_WidgetClassCssChangedFieldCallback -> IO (FunPtr C_WidgetClassCssChangedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassCssChangedFieldCallback</a></tt>.
noWidgetClassCssChangedFieldCallback :: Maybe WidgetClassCssChangedFieldCallback

-- | Wrap a <a>WidgetClassCssChangedFieldCallback</a> into a
--   <a>C_WidgetClassCssChangedFieldCallback</a>.
wrap_WidgetClassCssChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)) -> WidgetClassCssChangedFieldCallback -> C_WidgetClassCssChangedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassDirectionChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassDirectionChangedFieldCallback = Widget -> TextDirection -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassDirectionChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassDirectionChangedFieldCallback -> a -> TextDirection -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassDirectionChangedFieldCallback :: MonadIO m => WidgetClassDirectionChangedFieldCallback -> m (GClosure C_WidgetClassDirectionChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassDirectionChangedFieldCallback</a>.
mk_WidgetClassDirectionChangedFieldCallback :: C_WidgetClassDirectionChangedFieldCallback -> IO (FunPtr C_WidgetClassDirectionChangedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassDirectionChangedFieldCallback</a></tt>.
noWidgetClassDirectionChangedFieldCallback :: Maybe WidgetClassDirectionChangedFieldCallback

-- | Wrap a <a>WidgetClassDirectionChangedFieldCallback</a> into a
--   <a>C_WidgetClassDirectionChangedFieldCallback</a>.
wrap_WidgetClassDirectionChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassDirectionChangedFieldCallback)) -> WidgetClassDirectionChangedFieldCallback -> C_WidgetClassDirectionChangedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassFocusFieldCallback = Ptr Widget -> CUInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassFocusFieldCallback = Widget -> DirectionType -> IO Bool

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassFocusFieldCallback -> a -> DirectionType -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassFocusFieldCallback :: MonadIO m => WidgetClassFocusFieldCallback -> m (GClosure C_WidgetClassFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassFocusFieldCallback</a>.
mk_WidgetClassFocusFieldCallback :: C_WidgetClassFocusFieldCallback -> IO (FunPtr C_WidgetClassFocusFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassFocusFieldCallback</a></tt>.
noWidgetClassFocusFieldCallback :: Maybe WidgetClassFocusFieldCallback

-- | Wrap a <a>WidgetClassFocusFieldCallback</a> into a
--   <a>C_WidgetClassFocusFieldCallback</a>.
wrap_WidgetClassFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassFocusFieldCallback)) -> WidgetClassFocusFieldCallback -> C_WidgetClassFocusFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGetRequestModeFieldCallback = Ptr Widget -> IO CUInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassGetRequestModeFieldCallback = Widget -> IO SizeRequestMode

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGetRequestModeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGetRequestModeFieldCallback -> a -> m SizeRequestMode

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGetRequestModeFieldCallback :: MonadIO m => WidgetClassGetRequestModeFieldCallback -> m (GClosure C_WidgetClassGetRequestModeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGetRequestModeFieldCallback</a>.
mk_WidgetClassGetRequestModeFieldCallback :: C_WidgetClassGetRequestModeFieldCallback -> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGetRequestModeFieldCallback</a></tt>.
noWidgetClassGetRequestModeFieldCallback :: Maybe WidgetClassGetRequestModeFieldCallback

-- | Wrap a <a>WidgetClassGetRequestModeFieldCallback</a> into a
--   <a>C_WidgetClassGetRequestModeFieldCallback</a>.
wrap_WidgetClassGetRequestModeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)) -> WidgetClassGetRequestModeFieldCallback -> C_WidgetClassGetRequestModeFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassGrabFocusFieldCallback = Ptr Widget -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassGrabFocusFieldCallback = Widget -> IO Bool

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassGrabFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassGrabFocusFieldCallback -> a -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassGrabFocusFieldCallback :: MonadIO m => WidgetClassGrabFocusFieldCallback -> m (GClosure C_WidgetClassGrabFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassGrabFocusFieldCallback</a>.
mk_WidgetClassGrabFocusFieldCallback :: C_WidgetClassGrabFocusFieldCallback -> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassGrabFocusFieldCallback</a></tt>.
noWidgetClassGrabFocusFieldCallback :: Maybe WidgetClassGrabFocusFieldCallback

-- | Wrap a <a>WidgetClassGrabFocusFieldCallback</a> into a
--   <a>C_WidgetClassGrabFocusFieldCallback</a>.
wrap_WidgetClassGrabFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)) -> WidgetClassGrabFocusFieldCallback -> C_WidgetClassGrabFocusFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassHideFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassHideFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassHideFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassHideFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassHideFieldCallback :: MonadIO m => WidgetClassHideFieldCallback -> m (GClosure C_WidgetClassHideFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassHideFieldCallback</a>.
mk_WidgetClassHideFieldCallback :: C_WidgetClassHideFieldCallback -> IO (FunPtr C_WidgetClassHideFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassHideFieldCallback</a></tt>.
noWidgetClassHideFieldCallback :: Maybe WidgetClassHideFieldCallback

-- | Wrap a <a>WidgetClassHideFieldCallback</a> into a
--   <a>C_WidgetClassHideFieldCallback</a>.
wrap_WidgetClassHideFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassHideFieldCallback)) -> WidgetClassHideFieldCallback -> C_WidgetClassHideFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassKeynavFailedFieldCallback = Ptr Widget -> CUInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassKeynavFailedFieldCallback = Widget -> DirectionType -> IO Bool

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassKeynavFailedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassKeynavFailedFieldCallback -> a -> DirectionType -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassKeynavFailedFieldCallback :: MonadIO m => WidgetClassKeynavFailedFieldCallback -> m (GClosure C_WidgetClassKeynavFailedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassKeynavFailedFieldCallback</a>.
mk_WidgetClassKeynavFailedFieldCallback :: C_WidgetClassKeynavFailedFieldCallback -> IO (FunPtr C_WidgetClassKeynavFailedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassKeynavFailedFieldCallback</a></tt>.
noWidgetClassKeynavFailedFieldCallback :: Maybe WidgetClassKeynavFailedFieldCallback

-- | Wrap a <a>WidgetClassKeynavFailedFieldCallback</a> into a
--   <a>C_WidgetClassKeynavFailedFieldCallback</a>.
wrap_WidgetClassKeynavFailedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassKeynavFailedFieldCallback)) -> WidgetClassKeynavFailedFieldCallback -> C_WidgetClassKeynavFailedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMapFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassMapFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMapFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMapFieldCallback :: MonadIO m => WidgetClassMapFieldCallback -> m (GClosure C_WidgetClassMapFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMapFieldCallback</a>.
mk_WidgetClassMapFieldCallback :: C_WidgetClassMapFieldCallback -> IO (FunPtr C_WidgetClassMapFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMapFieldCallback</a></tt>.
noWidgetClassMapFieldCallback :: Maybe WidgetClassMapFieldCallback

-- | Wrap a <a>WidgetClassMapFieldCallback</a> into a
--   <a>C_WidgetClassMapFieldCallback</a>.
wrap_WidgetClassMapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMapFieldCallback)) -> WidgetClassMapFieldCallback -> C_WidgetClassMapFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMeasureFieldCallback = Ptr Widget -> CUInt -> Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> Ptr Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassMeasureFieldCallback = Widget -> Orientation -> Int32 -> IO (Int32, Int32, Int32, Int32)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMeasureFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMeasureFieldCallback -> a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMeasureFieldCallback :: MonadIO m => WidgetClassMeasureFieldCallback -> m (GClosure C_WidgetClassMeasureFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMeasureFieldCallback</a>.
mk_WidgetClassMeasureFieldCallback :: C_WidgetClassMeasureFieldCallback -> IO (FunPtr C_WidgetClassMeasureFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMeasureFieldCallback</a></tt>.
noWidgetClassMeasureFieldCallback :: Maybe WidgetClassMeasureFieldCallback

-- | Wrap a <a>WidgetClassMeasureFieldCallback</a> into a
--   <a>C_WidgetClassMeasureFieldCallback</a>.
wrap_WidgetClassMeasureFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMeasureFieldCallback)) -> WidgetClassMeasureFieldCallback -> C_WidgetClassMeasureFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMnemonicActivateFieldCallback = Ptr Widget -> CInt -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassMnemonicActivateFieldCallback = Widget -> Bool -> IO Bool

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMnemonicActivateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMnemonicActivateFieldCallback -> a -> Bool -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMnemonicActivateFieldCallback :: MonadIO m => WidgetClassMnemonicActivateFieldCallback -> m (GClosure C_WidgetClassMnemonicActivateFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMnemonicActivateFieldCallback</a>.
mk_WidgetClassMnemonicActivateFieldCallback :: C_WidgetClassMnemonicActivateFieldCallback -> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMnemonicActivateFieldCallback</a></tt>.
noWidgetClassMnemonicActivateFieldCallback :: Maybe WidgetClassMnemonicActivateFieldCallback

-- | Wrap a <a>WidgetClassMnemonicActivateFieldCallback</a> into a
--   <a>C_WidgetClassMnemonicActivateFieldCallback</a>.
wrap_WidgetClassMnemonicActivateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)) -> WidgetClassMnemonicActivateFieldCallback -> C_WidgetClassMnemonicActivateFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassMoveFocusFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassMoveFocusFieldCallback = Widget -> DirectionType -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassMoveFocusFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassMoveFocusFieldCallback -> a -> DirectionType -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassMoveFocusFieldCallback :: MonadIO m => WidgetClassMoveFocusFieldCallback -> m (GClosure C_WidgetClassMoveFocusFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassMoveFocusFieldCallback</a>.
mk_WidgetClassMoveFocusFieldCallback :: C_WidgetClassMoveFocusFieldCallback -> IO (FunPtr C_WidgetClassMoveFocusFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassMoveFocusFieldCallback</a></tt>.
noWidgetClassMoveFocusFieldCallback :: Maybe WidgetClassMoveFocusFieldCallback

-- | Wrap a <a>WidgetClassMoveFocusFieldCallback</a> into a
--   <a>C_WidgetClassMoveFocusFieldCallback</a>.
wrap_WidgetClassMoveFocusFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassMoveFocusFieldCallback)) -> WidgetClassMoveFocusFieldCallback -> C_WidgetClassMoveFocusFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassQueryTooltipFieldCallback = Ptr Widget -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> IO CInt

-- | <i>No description available in the introspection data.</i>
type WidgetClassQueryTooltipFieldCallback = Widget -> Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassQueryTooltipFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsTooltip b) => FunPtr C_WidgetClassQueryTooltipFieldCallback -> a -> Int32 -> Int32 -> Bool -> b -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassQueryTooltipFieldCallback :: MonadIO m => WidgetClassQueryTooltipFieldCallback -> m (GClosure C_WidgetClassQueryTooltipFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassQueryTooltipFieldCallback</a>.
mk_WidgetClassQueryTooltipFieldCallback :: C_WidgetClassQueryTooltipFieldCallback -> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassQueryTooltipFieldCallback</a></tt>.
noWidgetClassQueryTooltipFieldCallback :: Maybe WidgetClassQueryTooltipFieldCallback

-- | Wrap a <a>WidgetClassQueryTooltipFieldCallback</a> into a
--   <a>C_WidgetClassQueryTooltipFieldCallback</a>.
wrap_WidgetClassQueryTooltipFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)) -> WidgetClassQueryTooltipFieldCallback -> C_WidgetClassQueryTooltipFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassRealizeFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassRealizeFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassRealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassRealizeFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassRealizeFieldCallback :: MonadIO m => WidgetClassRealizeFieldCallback -> m (GClosure C_WidgetClassRealizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassRealizeFieldCallback</a>.
mk_WidgetClassRealizeFieldCallback :: C_WidgetClassRealizeFieldCallback -> IO (FunPtr C_WidgetClassRealizeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassRealizeFieldCallback</a></tt>.
noWidgetClassRealizeFieldCallback :: Maybe WidgetClassRealizeFieldCallback

-- | Wrap a <a>WidgetClassRealizeFieldCallback</a> into a
--   <a>C_WidgetClassRealizeFieldCallback</a>.
wrap_WidgetClassRealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRealizeFieldCallback)) -> WidgetClassRealizeFieldCallback -> C_WidgetClassRealizeFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassRootFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassRootFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassRootFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassRootFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassRootFieldCallback :: MonadIO m => WidgetClassRootFieldCallback -> m (GClosure C_WidgetClassRootFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassRootFieldCallback</a>.
mk_WidgetClassRootFieldCallback :: C_WidgetClassRootFieldCallback -> IO (FunPtr C_WidgetClassRootFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassRootFieldCallback</a></tt>.
noWidgetClassRootFieldCallback :: Maybe WidgetClassRootFieldCallback

-- | Wrap a <a>WidgetClassRootFieldCallback</a> into a
--   <a>C_WidgetClassRootFieldCallback</a>.
wrap_WidgetClassRootFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassRootFieldCallback)) -> WidgetClassRootFieldCallback -> C_WidgetClassRootFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSetFocusChildFieldCallback = Ptr Widget -> Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassSetFocusChildFieldCallback = Widget -> Maybe Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSetFocusChildFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => FunPtr C_WidgetClassSetFocusChildFieldCallback -> a -> Maybe b -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSetFocusChildFieldCallback :: MonadIO m => WidgetClassSetFocusChildFieldCallback -> m (GClosure C_WidgetClassSetFocusChildFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSetFocusChildFieldCallback</a>.
mk_WidgetClassSetFocusChildFieldCallback :: C_WidgetClassSetFocusChildFieldCallback -> IO (FunPtr C_WidgetClassSetFocusChildFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSetFocusChildFieldCallback</a></tt>.
noWidgetClassSetFocusChildFieldCallback :: Maybe WidgetClassSetFocusChildFieldCallback

-- | Wrap a <a>WidgetClassSetFocusChildFieldCallback</a> into a
--   <a>C_WidgetClassSetFocusChildFieldCallback</a>.
wrap_WidgetClassSetFocusChildFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)) -> WidgetClassSetFocusChildFieldCallback -> C_WidgetClassSetFocusChildFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassShowFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassShowFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassShowFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassShowFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassShowFieldCallback :: MonadIO m => WidgetClassShowFieldCallback -> m (GClosure C_WidgetClassShowFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassShowFieldCallback</a>.
mk_WidgetClassShowFieldCallback :: C_WidgetClassShowFieldCallback -> IO (FunPtr C_WidgetClassShowFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassShowFieldCallback</a></tt>.
noWidgetClassShowFieldCallback :: Maybe WidgetClassShowFieldCallback

-- | Wrap a <a>WidgetClassShowFieldCallback</a> into a
--   <a>C_WidgetClassShowFieldCallback</a>.
wrap_WidgetClassShowFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassShowFieldCallback)) -> WidgetClassShowFieldCallback -> C_WidgetClassShowFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSizeAllocateFieldCallback = Ptr Widget -> Int32 -> Int32 -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassSizeAllocateFieldCallback = Widget -> Int32 -> Int32 -> Int32 -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSizeAllocateFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSizeAllocateFieldCallback -> a -> Int32 -> Int32 -> Int32 -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSizeAllocateFieldCallback :: MonadIO m => WidgetClassSizeAllocateFieldCallback -> m (GClosure C_WidgetClassSizeAllocateFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSizeAllocateFieldCallback</a>.
mk_WidgetClassSizeAllocateFieldCallback :: C_WidgetClassSizeAllocateFieldCallback -> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSizeAllocateFieldCallback</a></tt>.
noWidgetClassSizeAllocateFieldCallback :: Maybe WidgetClassSizeAllocateFieldCallback

-- | Wrap a <a>WidgetClassSizeAllocateFieldCallback</a> into a
--   <a>C_WidgetClassSizeAllocateFieldCallback</a>.
wrap_WidgetClassSizeAllocateFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)) -> WidgetClassSizeAllocateFieldCallback -> C_WidgetClassSizeAllocateFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSnapshotFieldCallback = Ptr Widget -> Ptr Snapshot -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassSnapshotFieldCallback = Widget -> Snapshot -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSnapshotFieldCallback :: (HasCallStack, MonadIO m, IsWidget a, IsSnapshot b) => FunPtr C_WidgetClassSnapshotFieldCallback -> a -> b -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSnapshotFieldCallback :: MonadIO m => WidgetClassSnapshotFieldCallback -> m (GClosure C_WidgetClassSnapshotFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSnapshotFieldCallback</a>.
mk_WidgetClassSnapshotFieldCallback :: C_WidgetClassSnapshotFieldCallback -> IO (FunPtr C_WidgetClassSnapshotFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSnapshotFieldCallback</a></tt>.
noWidgetClassSnapshotFieldCallback :: Maybe WidgetClassSnapshotFieldCallback

-- | Wrap a <a>WidgetClassSnapshotFieldCallback</a> into a
--   <a>C_WidgetClassSnapshotFieldCallback</a>.
wrap_WidgetClassSnapshotFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)) -> WidgetClassSnapshotFieldCallback -> C_WidgetClassSnapshotFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassStateFlagsChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassStateFlagsChangedFieldCallback = Widget -> [StateFlags] -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassStateFlagsChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> a -> [StateFlags] -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassStateFlagsChangedFieldCallback :: MonadIO m => WidgetClassStateFlagsChangedFieldCallback -> m (GClosure C_WidgetClassStateFlagsChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassStateFlagsChangedFieldCallback</a>.
mk_WidgetClassStateFlagsChangedFieldCallback :: C_WidgetClassStateFlagsChangedFieldCallback -> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassStateFlagsChangedFieldCallback</a></tt>.
noWidgetClassStateFlagsChangedFieldCallback :: Maybe WidgetClassStateFlagsChangedFieldCallback

-- | Wrap a <a>WidgetClassStateFlagsChangedFieldCallback</a> into a
--   <a>C_WidgetClassStateFlagsChangedFieldCallback</a>.
wrap_WidgetClassStateFlagsChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)) -> WidgetClassStateFlagsChangedFieldCallback -> C_WidgetClassStateFlagsChangedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassSystemSettingChangedFieldCallback = Ptr Widget -> CUInt -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassSystemSettingChangedFieldCallback = Widget -> SystemSetting -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassSystemSettingChangedFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassSystemSettingChangedFieldCallback -> a -> SystemSetting -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassSystemSettingChangedFieldCallback :: MonadIO m => WidgetClassSystemSettingChangedFieldCallback -> m (GClosure C_WidgetClassSystemSettingChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassSystemSettingChangedFieldCallback</a>.
mk_WidgetClassSystemSettingChangedFieldCallback :: C_WidgetClassSystemSettingChangedFieldCallback -> IO (FunPtr C_WidgetClassSystemSettingChangedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassSystemSettingChangedFieldCallback</a></tt>.
noWidgetClassSystemSettingChangedFieldCallback :: Maybe WidgetClassSystemSettingChangedFieldCallback

-- | Wrap a <a>WidgetClassSystemSettingChangedFieldCallback</a> into a
--   <a>C_WidgetClassSystemSettingChangedFieldCallback</a>.
wrap_WidgetClassSystemSettingChangedFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassSystemSettingChangedFieldCallback)) -> WidgetClassSystemSettingChangedFieldCallback -> C_WidgetClassSystemSettingChangedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassUnmapFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassUnmapFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassUnmapFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnmapFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassUnmapFieldCallback :: MonadIO m => WidgetClassUnmapFieldCallback -> m (GClosure C_WidgetClassUnmapFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassUnmapFieldCallback</a>.
mk_WidgetClassUnmapFieldCallback :: C_WidgetClassUnmapFieldCallback -> IO (FunPtr C_WidgetClassUnmapFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassUnmapFieldCallback</a></tt>.
noWidgetClassUnmapFieldCallback :: Maybe WidgetClassUnmapFieldCallback

-- | Wrap a <a>WidgetClassUnmapFieldCallback</a> into a
--   <a>C_WidgetClassUnmapFieldCallback</a>.
wrap_WidgetClassUnmapFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnmapFieldCallback)) -> WidgetClassUnmapFieldCallback -> C_WidgetClassUnmapFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassUnrealizeFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassUnrealizeFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassUnrealizeFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnrealizeFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassUnrealizeFieldCallback :: MonadIO m => WidgetClassUnrealizeFieldCallback -> m (GClosure C_WidgetClassUnrealizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassUnrealizeFieldCallback</a>.
mk_WidgetClassUnrealizeFieldCallback :: C_WidgetClassUnrealizeFieldCallback -> IO (FunPtr C_WidgetClassUnrealizeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassUnrealizeFieldCallback</a></tt>.
noWidgetClassUnrealizeFieldCallback :: Maybe WidgetClassUnrealizeFieldCallback

-- | Wrap a <a>WidgetClassUnrealizeFieldCallback</a> into a
--   <a>C_WidgetClassUnrealizeFieldCallback</a>.
wrap_WidgetClassUnrealizeFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrealizeFieldCallback)) -> WidgetClassUnrealizeFieldCallback -> C_WidgetClassUnrealizeFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_WidgetClassUnrootFieldCallback = Ptr Widget -> IO ()

-- | <i>No description available in the introspection data.</i>
type WidgetClassUnrootFieldCallback = Widget -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_WidgetClassUnrootFieldCallback :: (HasCallStack, MonadIO m, IsWidget a) => FunPtr C_WidgetClassUnrootFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_WidgetClassUnrootFieldCallback :: MonadIO m => WidgetClassUnrootFieldCallback -> m (GClosure C_WidgetClassUnrootFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WidgetClassUnrootFieldCallback</a>.
mk_WidgetClassUnrootFieldCallback :: C_WidgetClassUnrootFieldCallback -> IO (FunPtr C_WidgetClassUnrootFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WidgetClassUnrootFieldCallback</a></tt>.
noWidgetClassUnrootFieldCallback :: Maybe WidgetClassUnrootFieldCallback

-- | Wrap a <a>WidgetClassUnrootFieldCallback</a> into a
--   <a>C_WidgetClassUnrootFieldCallback</a>.
wrap_WidgetClassUnrootFieldCallback :: Maybe (Ptr (FunPtr C_WidgetClassUnrootFieldCallback)) -> WidgetClassUnrootFieldCallback -> C_WidgetClassUnrootFieldCallback


-- | Iterates over the contents of a <tt>GtkTextBuffer</tt>.
--   
--   You may wish to begin by reading the <a>text widget conceptual
--   overview</a>, which gives an overview of all the objects and data
--   types related to the text widget and how they work together.
module GI.Gtk.Structs.TextIter

-- | Memory-managed wrapper type.
newtype TextIter
TextIter :: ManagedPtr TextIter -> TextIter

-- | Construct a <a>TextIter</a> struct initialized to zero.
newZeroTextIter :: MonadIO m => m TextIter

-- | Assigns the value of <i><tt>other</tt></i> to <i><tt>iter</tt></i>.
--   
--   This function is not useful in applications, because iterators can be
--   assigned with <tt>GtkTextIter i = j;</tt>.
--   
--   The function is used by language bindings.
textIterAssign :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m ()

-- | Moves backward by one character offset.
--   
--   Returns <a>True</a> if movement was possible; if <i><tt>iter</tt></i>
--   was the first in the buffer (character offset 0), this function
--   returns <a>False</a> for convenience when writing loops.
textIterBackwardChar :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> characters backward, if possible.
--   
--   If <i><tt>count</tt></i> would move past the start or end of the
--   buffer, moves to the start or end of the buffer.
--   
--   The return value indicates whether the iterator moved onto a
--   dereferenceable position; if the iterator didn’t move, or moved onto
--   the end iterator, then <a>False</a> is returned. If
--   <i><tt>count</tt></i> is 0, the function does nothing and returns
--   <a>False</a>.
textIterBackwardChars :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Like <a>textIterForwardCursorPosition</a>, but moves backward.
textIterBackwardCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> cursor positions.
--   
--   See <a>textIterForwardCursorPosition</a> for details.
textIterBackwardCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Same as <a>textIterForwardFindChar</a>, but goes backward from
--   <i><tt>iter</tt></i>.
textIterBackwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the previous line.
--   
--   Returns <a>True</a> if <i><tt>iter</tt></i> could be moved; i.e. if
--   <i><tt>iter</tt></i> was at character offset 0, this function returns
--   <a>False</a>. Therefore, if <i><tt>iter</tt></i> was already on line
--   0, but not at the start of the line, <i><tt>iter</tt></i> is snapped
--   to the start of the line and the function returns <a>True</a>. (Note
--   that this implies that in a loop calling this function, the line
--   number may not change on every iteration, if your first iteration is
--   on line 0.)
textIterBackwardLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> lines backward, if possible.
--   
--   If <i><tt>count</tt></i> would move past the start or end of the
--   buffer, moves to the start or end of the buffer.
--   
--   The return value indicates whether the iterator moved onto a
--   dereferenceable position; if the iterator didn’t move, or moved onto
--   the end iterator, then <a>False</a> is returned. If
--   <i><tt>count</tt></i> is 0, the function does nothing and returns
--   <a>False</a>. If <i><tt>count</tt></i> is negative, moves forward by 0
--   - <i><tt>count</tt></i> lines.
textIterBackwardLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Same as <a>textIterForwardSearch</a>, but moves backward.
--   
--   <i><tt>matchEnd</tt></i> will never be set to a <tt>GtkTextIter</tt>
--   located after <i><tt>iter</tt></i>, even if there is a possible
--   <i><tt>matchStart</tt></i> before or at <i><tt>iter</tt></i>.
textIterBackwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

-- | Moves backward to the previous sentence start.
--   
--   If <i><tt>iter</tt></i> is already at the start of a sentence, moves
--   backward to the next one.
--   
--   Sentence boundaries are determined by Pango and should be correct for
--   nearly any language.
textIterBackwardSentenceStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterBackwardSentenceStart</a> up to <i><tt>count</tt></i>
--   times.
--   
--   If <i><tt>count</tt></i> is negative, moves forward instead of
--   backward.
textIterBackwardSentenceStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves backward to the next toggle (on or off) of the
--   <i><tt>tag</tt></i>, or to the next toggle of any tag if
--   <i><tt>tag</tt></i> is <a>Nothing</a>.
--   
--   If no matching tag toggles are found, returns <a>False</a>, otherwise
--   <a>True</a>. Does not return toggles located at <i><tt>iter</tt></i>,
--   only toggles before <i><tt>iter</tt></i>. Sets <i><tt>iter</tt></i> to
--   the location of the toggle, or the start of the buffer if no toggle is
--   found.
textIterBackwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Moves <i><tt>iter</tt></i> backward to the previous visible cursor
--   position.
--   
--   See <a>textIterBackwardCursorPosition</a> for details.
textIterBackwardVisibleCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> visible cursor positions.
--   
--   See <a>textIterBackwardCursorPosition</a> for details.
textIterBackwardVisibleCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the previous visible line.
--   
--   Returns <a>True</a> if <i><tt>iter</tt></i> could be moved; i.e. if
--   <i><tt>iter</tt></i> was at character offset 0, this function returns
--   <a>False</a>. Therefore if <i><tt>iter</tt></i> was already on line 0,
--   but not at the start of the line, <i><tt>iter</tt></i> is snapped to
--   the start of the line and the function returns <a>True</a>. (Note that
--   this implies that in a loop calling this function, the line number may
--   not change on every iteration, if your first iteration is on line 0.)
textIterBackwardVisibleLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> visible lines backward, if possible.
--   
--   If <i><tt>count</tt></i> would move past the start or end of the
--   buffer, moves to the start or end of the buffer.
--   
--   The return value indicates whether the iterator moved onto a
--   dereferenceable position; if the iterator didn’t move, or moved onto
--   the end iterator, then <a>False</a> is returned. If
--   <i><tt>count</tt></i> is 0, the function does nothing and returns
--   <a>False</a>. If <i><tt>count</tt></i> is negative, moves forward by 0
--   - <i><tt>count</tt></i> lines.
textIterBackwardVisibleLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves backward to the previous visible word start.
--   
--   If <i><tt>iter</tt></i> is currently on a word start, moves backward
--   to the next one after that.
--   
--   Word breaks are determined by Pango and should be correct for nearly
--   any language.
textIterBackwardVisibleWordStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterBackwardVisibleWordStart</a> up to
--   <i><tt>count</tt></i> times.
textIterBackwardVisibleWordStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves backward to the previous word start.
--   
--   If <i><tt>iter</tt></i> is currently on a word start, moves backward
--   to the next one after that.
--   
--   Word breaks are determined by Pango and should be correct for nearly
--   any language
textIterBackwardWordStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterBackwardWordStart</a> up to <i><tt>count</tt></i>
--   times.
textIterBackwardWordStarts :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Considering the default editability of the buffer, and tags that
--   affect editability, determines whether text inserted at
--   <i><tt>iter</tt></i> would be editable.
--   
--   If text inserted at <i><tt>iter</tt></i> would be editable then the
--   user should be allowed to insert text at <i><tt>iter</tt></i>.
--   <a>textBufferInsertInteractive</a> uses this function to decide
--   whether insertions are allowed at a given position.
textIterCanInsert :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m Bool

-- | A <tt><i>qsort()</i></tt>-style function that returns negative if
--   <i><tt>lhs</tt></i> is less than <i><tt>rhs</tt></i>, positive if
--   <i><tt>lhs</tt></i> is greater than <i><tt>rhs</tt></i>, and 0 if
--   they’re equal.
--   
--   Ordering is in character offset order, i.e. the first character in the
--   buffer is less than the second character in the buffer.
textIterCompare :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Int32

-- | Creates a dynamically-allocated copy of an iterator.
--   
--   This function is not useful in applications, because iterators can be
--   copied with a simple assignment (<tt>GtkTextIter i = j;</tt>).
--   
--   The function is used by language bindings.
textIterCopy :: (HasCallStack, MonadIO m) => TextIter -> m TextIter

-- | Returns whether the character at <i><tt>iter</tt></i> is within an
--   editable region of text.
--   
--   Non-editable text is “locked” and can’t be changed by the user via
--   <tt>GtkTextView</tt>. If no tags applied to this text affect
--   editability, <i><tt>defaultSetting</tt></i> will be returned.
--   
--   You don’t want to use this function to decide whether text can be
--   inserted at <i><tt>iter</tt></i>, because for insertion you don’t want
--   to know whether the char at <i><tt>iter</tt></i> is inside an editable
--   range, you want to know whether a new character inserted at
--   <i><tt>iter</tt></i> would be inside an editable range. Use
--   <a>textIterCanInsert</a> to handle this case.
textIterEditable :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m Bool

-- | Returns <a>True</a> if <i><tt>iter</tt></i> points to the start of the
--   paragraph delimiter characters for a line.
--   
--   Delimiters will be either a newline, a carriage return, a carriage
--   return followed by a newline, or a Unicode paragraph separator
--   character.
--   
--   Note that an iterator pointing to the \n of a \r\n pair will not be
--   counted as the end of a line, the line ends before the \r. The end
--   iterator is considered to be at the end of a line, even though there
--   are no paragraph delimiter chars there.
textIterEndsLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Determines whether <i><tt>iter</tt></i> ends a sentence.
--   
--   Sentence boundaries are determined by Pango and should be correct for
--   nearly any language.
textIterEndsSentence :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>tag</tt></i> is toggled off at exactly
--   this point.
--   
--   If <i><tt>tag</tt></i> is <a>Nothing</a>, returns <a>True</a> if any
--   tag is toggled off at this point.
--   
--   Note that if this function returns <a>True</a>, it means that
--   <i><tt>iter</tt></i> is at the end of the tagged range, but that the
--   character at <i><tt>iter</tt></i> is outside the tagged range. In
--   other words, unlike <a>textIterStartsTag</a>, if this function returns
--   <a>True</a>, <a>textIterHasTag</a> will return <a>False</a> for the
--   same parameters.
textIterEndsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Determines whether <i><tt>iter</tt></i> ends a natural-language word.
--   
--   Word breaks are determined by Pango and should be correct for nearly
--   any language.
textIterEndsWord :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Tests whether two iterators are equal, using the fastest possible
--   mechanism.
--   
--   This function is very fast; you can expect it to perform better than
--   e.g. getting the character offset for each iterator and comparing the
--   offsets yourself. Also, it’s a bit faster than <a>textIterCompare</a>.
textIterEqual :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Bool

-- | Moves <i><tt>iter</tt></i> forward by one character offset.
--   
--   Note that images embedded in the buffer occupy 1 character slot, so
--   this function may actually move onto an image instead of a character,
--   if you have images in your buffer. If <i><tt>iter</tt></i> is the end
--   iterator or one character before it, <i><tt>iter</tt></i> will now
--   point at the end iterator, and this function returns <a>False</a> for
--   convenience when writing loops.
textIterForwardChar :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> characters if possible.
--   
--   If <i><tt>count</tt></i> would move past the start or end of the
--   buffer, moves to the start or end of the buffer.
--   
--   The return value indicates whether the new position of
--   <i><tt>iter</tt></i> is different from its original position, and
--   dereferenceable (the last iterator in the buffer is not
--   dereferenceable). If <i><tt>count</tt></i> is 0, the function does
--   nothing and returns <a>False</a>.
textIterForwardChars :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> forward by a single cursor position.
--   
--   Cursor positions are (unsurprisingly) positions where the cursor can
--   appear. Perhaps surprisingly, there may not be a cursor position
--   between all characters. The most common example for European languages
--   would be a carriage return/newline sequence.
--   
--   For some Unicode characters, the equivalent of say the letter “a” with
--   an accent mark will be represented as two characters, first the letter
--   then a "combining mark" that causes the accent to be rendered; so the
--   cursor can’t go between those two characters.
--   
--   See also the <a>LogAttr</a> struct and the <a>break</a> function.
textIterForwardCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> cursor positions.
--   
--   See <a>textIterForwardCursorPosition</a> for details.
textIterForwardCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Advances <i><tt>iter</tt></i>, calling <i><tt>pred</tt></i> on each
--   character.
--   
--   If <i><tt>pred</tt></i> returns <a>True</a>, returns <a>True</a> and
--   stops scanning. If <i><tt>pred</tt></i> never returns <a>True</a>,
--   <i><tt>iter</tt></i> is set to <i><tt>limit</tt></i> if
--   <i><tt>limit</tt></i> is non-<a>Nothing</a>, otherwise to the end
--   iterator.
textIterForwardFindChar :: (HasCallStack, MonadIO m) => TextIter -> TextCharPredicate -> Maybe TextIter -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the next line.
--   
--   If the iter is already on the last line of the buffer, moves the iter
--   to the end of the current line. If after the operation, the iter is at
--   the end of the buffer and not dereferenceable, returns <a>False</a>.
--   Otherwise, returns <a>True</a>.
textIterForwardLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> lines forward, if possible.
--   
--   If <i><tt>count</tt></i> would move past the start or end of the
--   buffer, moves to the start or end of the buffer.
--   
--   The return value indicates whether the iterator moved onto a
--   dereferenceable position; if the iterator didn’t move, or moved onto
--   the end iterator, then <a>False</a> is returned. If
--   <i><tt>count</tt></i> is 0, the function does nothing and returns
--   <a>False</a>. If <i><tt>count</tt></i> is negative, moves backward by
--   0 - <i><tt>count</tt></i> lines.
textIterForwardLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Searches forward for <i><tt>str</tt></i>.
--   
--   Any match is returned by setting <i><tt>matchStart</tt></i> to the
--   first character of the match and <i><tt>matchEnd</tt></i> to the first
--   character after the match. The search will not continue past
--   <i><tt>limit</tt></i>. Note that a search is a linear or O(n)
--   operation, so you may wish to use <i><tt>limit</tt></i> to avoid
--   locking up your UI on large buffers.
--   
--   <i><tt>matchStart</tt></i> will never be set to a <tt>GtkTextIter</tt>
--   located before <i><tt>iter</tt></i>, even if there is a possible
--   <i><tt>matchEnd</tt></i> after or at <i><tt>iter</tt></i>.
textIterForwardSearch :: (HasCallStack, MonadIO m) => TextIter -> Text -> [TextSearchFlags] -> Maybe TextIter -> m (Bool, TextIter, TextIter)

-- | Moves forward to the next sentence end.
--   
--   If <i><tt>iter</tt></i> is at the end of a sentence, moves to the next
--   end of sentence.
--   
--   Sentence boundaries are determined by Pango and should be correct for
--   nearly any language.
textIterForwardSentenceEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterForwardSentenceEnd</a> <i><tt>count</tt></i> times.
--   
--   If <i><tt>count</tt></i> is negative, moves backward instead of
--   forward.
textIterForwardSentenceEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the “end iterator”, which points
--   one past the last valid character in the buffer.
--   
--   <a>textIterGetChar</a> called on the end iterator returns 0, which is
--   convenient for writing loops.
textIterForwardToEnd :: (HasCallStack, MonadIO m) => TextIter -> m ()

-- | Moves the iterator to point to the paragraph delimiter characters.
--   
--   The possible characters are either a newline, a carriage return, a
--   carriage return/newline in sequence, or the Unicode paragraph
--   separator character.
--   
--   If the iterator is already at the paragraph delimiter characters,
--   moves to the paragraph delimiter characters for the next line. If
--   <i><tt>iter</tt></i> is on the last line in the buffer, which does not
--   end in paragraph delimiters, moves to the end iterator (end of the
--   last line), and returns <a>False</a>.
textIterForwardToLineEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves forward to the next toggle (on or off) of the
--   <i><tt>tag</tt></i>, or to the next toggle of any tag if
--   <i><tt>tag</tt></i> is <a>Nothing</a>.
--   
--   If no matching tag toggles are found, returns <a>False</a>, otherwise
--   <a>True</a>. Does not return toggles located at <i><tt>iter</tt></i>,
--   only toggles after <i><tt>iter</tt></i>. Sets <i><tt>iter</tt></i> to
--   the location of the toggle, or to the end of the buffer if no toggle
--   is found.
textIterForwardToTagToggle :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the next visible cursor
--   position.
--   
--   See <a>textIterForwardCursorPosition</a> for details.
textIterForwardVisibleCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves up to <i><tt>count</tt></i> visible cursor positions.
--   
--   See <a>textIterForwardCursorPosition</a> for details.
textIterForwardVisibleCursorPositions :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves <i><tt>iter</tt></i> to the start of the next visible line.
--   
--   Returns <a>True</a> if there was a next line to move to, and
--   <a>False</a> if <i><tt>iter</tt></i> was simply moved to the end of
--   the buffer and is now not dereferenceable, or if <i><tt>iter</tt></i>
--   was already at the end of the buffer.
textIterForwardVisibleLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Moves <i><tt>count</tt></i> visible lines forward, if possible.
--   
--   If <i><tt>count</tt></i> would move past the start or end of the
--   buffer, moves to the start or end of the buffer.
--   
--   The return value indicates whether the iterator moved onto a
--   dereferenceable position; if the iterator didn’t move, or moved onto
--   the end iterator, then <a>False</a> is returned. If
--   <i><tt>count</tt></i> is 0, the function does nothing and returns
--   <a>False</a>. If <i><tt>count</tt></i> is negative, moves backward by
--   0 - <i><tt>count</tt></i> lines.
textIterForwardVisibleLines :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves forward to the next visible word end.
--   
--   If <i><tt>iter</tt></i> is currently on a word end, moves forward to
--   the next one after that.
--   
--   Word breaks are determined by Pango and should be correct for nearly
--   any language
textIterForwardVisibleWordEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterForwardVisibleWordEnd</a> up to <i><tt>count</tt></i>
--   times.
textIterForwardVisibleWordEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Moves forward to the next word end.
--   
--   If <i><tt>iter</tt></i> is currently on a word end, moves forward to
--   the next one after that.
--   
--   Word breaks are determined by Pango and should be correct for nearly
--   any language.
textIterForwardWordEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Calls <a>textIterForwardWordEnd</a> up to <i><tt>count</tt></i> times.
textIterForwardWordEnds :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m Bool

-- | Free an iterator allocated on the heap.
--   
--   This function is intended for use in language bindings, and is not
--   especially useful for applications, because iterators can simply be
--   allocated on the stack.
textIterFree :: (HasCallStack, MonadIO m) => TextIter -> m ()

-- | Returns the <tt>GtkTextBuffer</tt> this iterator is associated with.
textIterGetBuffer :: (HasCallStack, MonadIO m) => TextIter -> m TextBuffer

-- | Returns the number of bytes in the line containing
--   <i><tt>iter</tt></i>, including the paragraph delimiters.
textIterGetBytesInLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | The Unicode character at this iterator is returned.
--   
--   Equivalent to operator* on a C++ iterator. If the element at this
--   iterator is a non-character element, such as an image embedded in the
--   buffer, the Unicode “unknown” character 0xFFFC is returned. If invoked
--   on the end iterator, zero is returned; zero is not a valid Unicode
--   character.
--   
--   So you can write a loop which ends when this function returns 0.
textIterGetChar :: (HasCallStack, MonadIO m) => TextIter -> m Char

-- | Returns the number of characters in the line containing
--   <i><tt>iter</tt></i>, including the paragraph delimiters.
textIterGetCharsInLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | If the location at <i><tt>iter</tt></i> contains a child anchor, the
--   anchor is returned.
--   
--   Otherwise, <a>Nothing</a> is returned.
textIterGetChildAnchor :: (HasCallStack, MonadIO m) => TextIter -> m (Maybe TextChildAnchor)

-- | Returns the language in effect at <i><tt>iter</tt></i>.
--   
--   If no tags affecting language apply to <i><tt>iter</tt></i>, the
--   return value is identical to that of <a>getDefaultLanguage</a>.
textIterGetLanguage :: (HasCallStack, MonadIO m) => TextIter -> m Language

-- | Returns the line number containing the iterator.
--   
--   Lines in a <tt>GtkTextBuffer</tt> are numbered beginning with 0 for
--   the first line in the buffer.
textIterGetLine :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the byte index of the iterator, counting from the start of a
--   newline-terminated line.
--   
--   Remember that <tt>GtkTextBuffer</tt> encodes text in UTF-8, and that
--   characters can require a variable number of bytes to represent.
textIterGetLineIndex :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the character offset of the iterator, counting from the start
--   of a newline-terminated line.
--   
--   The first character on the line has offset 0.
textIterGetLineOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns a list of all <tt>GtkTextMark</tt> at this location.
--   
--   Because marks are not iterable (they don’t take up any "space" in the
--   buffer, they are just marks in between iterable locations), multiple
--   marks can exist in the same place.
--   
--   The returned list is not in any meaningful order.
textIterGetMarks :: (HasCallStack, MonadIO m) => TextIter -> m [TextMark]

-- | Returns the character offset of an iterator.
--   
--   Each character in a <tt>GtkTextBuffer</tt> has an offset, starting
--   with 0 for the first character in the buffer. Use
--   <a>textBufferGetIterAtOffset</a> to convert an offset back into an
--   iterator.
textIterGetOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | If the element at <i><tt>iter</tt></i> is a paintable, the paintable
--   is returned.
--   
--   Otherwise, <a>Nothing</a> is returned.
textIterGetPaintable :: (HasCallStack, MonadIO m) => TextIter -> m (Maybe Paintable)

-- | Returns the text in the given range.
--   
--   A “slice” is an array of characters encoded in UTF-8 format, including
--   the Unicode “unknown” character 0xFFFC for iterable non-character
--   elements in the buffer, such as images. Because images are encoded in
--   the slice, byte and character offsets in the returned array will
--   correspond to byte offsets in the text buffer. Note that 0xFFFC can
--   occur in normal text as well, so it is not a reliable indicator that a
--   paintable or widget is in the buffer.
textIterGetSlice :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Returns a list of tags that apply to <i><tt>iter</tt></i>, in
--   ascending order of priority.
--   
--   The highest-priority tags are last.
--   
--   The <tt>GtkTextTag</tt>s in the list don’t have a reference added, but
--   you have to free the list itself.
textIterGetTags :: (HasCallStack, MonadIO m) => TextIter -> m [TextTag]

-- | Returns text in the given range.
--   
--   If the range contains non-text elements such as images, the character
--   and byte offsets in the returned string will not correspond to
--   character and byte offsets in the buffer. If you want offsets to
--   correspond, see <a>textIterGetSlice</a>.
textIterGetText :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Returns a list of <tt>GtkTextTag</tt> that are toggled on or off at
--   this point.
--   
--   If <i><tt>toggledOn</tt></i> is <a>True</a>, the list contains tags
--   that are toggled on. If a tag is toggled on at <i><tt>iter</tt></i>,
--   then some non-empty range of characters following <i><tt>iter</tt></i>
--   has that tag applied to it. If a tag is toggled off, then some
--   non-empty range following <i><tt>iter</tt></i> does not have the tag
--   applied to it.
textIterGetToggledTags :: (HasCallStack, MonadIO m) => TextIter -> Bool -> m [TextTag]

-- | Returns the number of bytes from the start of the line to the given
--   <i><tt>iter</tt></i>, not counting bytes that are invisible due to
--   tags with the “invisible” flag toggled on.
textIterGetVisibleLineIndex :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns the offset in characters from the start of the line to the
--   given <i><tt>iter</tt></i>, not counting characters that are invisible
--   due to tags with the “invisible” flag toggled on.
textIterGetVisibleLineOffset :: (HasCallStack, MonadIO m) => TextIter -> m Int32

-- | Returns visible text in the given range.
--   
--   Like <a>textIterGetSlice</a>, but invisible text is not included.
--   Invisible text is usually invisible because a <tt>GtkTextTag</tt> with
--   the “invisible” attribute turned on has been applied to it.
textIterGetVisibleSlice :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Returns visible text in the given range.
--   
--   Like <a>textIterGetText</a>, but invisible text is not included.
--   Invisible text is usually invisible because a <tt>GtkTextTag</tt> with
--   the “invisible” attribute turned on has been applied to it.
textIterGetVisibleText :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m Text

-- | Returns <a>True</a> if <i><tt>iter</tt></i> points to a character that
--   is part of a range tagged with <i><tt>tag</tt></i>.
--   
--   See also <a>textIterStartsTag</a> and <a>textIterEndsTag</a>.
textIterHasTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> a -> m Bool

-- | Checks whether <i><tt>iter</tt></i> falls in the range
--   [<i><tt>start</tt></i>, <i><tt>end</tt></i>).
--   
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> must be in ascending
--   order.
textIterInRange :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> TextIter -> m Bool

-- | Determines whether <i><tt>iter</tt></i> is inside a sentence (as
--   opposed to in between two sentences, e.g. after a period and before
--   the first letter of the next sentence).
--   
--   Sentence boundaries are determined by Pango and should be correct for
--   nearly any language.
textIterInsideSentence :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Determines whether the character pointed by <i><tt>iter</tt></i> is
--   part of a natural-language word (as opposed to say inside some
--   whitespace).
--   
--   Word breaks are determined by Pango and should be correct for nearly
--   any language.
--   
--   Note that if <a>textIterStartsWord</a> returns <a>True</a>, then this
--   function returns <a>True</a> too, since <i><tt>iter</tt></i> points to
--   the first character of the word.
textIterInsideWord :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Determine if <i><tt>iter</tt></i> is at a cursor position.
--   
--   See <a>textIterForwardCursorPosition</a> or <a>LogAttr</a> or
--   <a>break</a> for details on what a cursor position is.
textIterIsCursorPosition :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>iter</tt></i> is the end iterator.
--   
--   This means it is one past the last dereferenceable iterator in the
--   buffer. <a>textIterIsEnd</a> is the most efficient way to check
--   whether an iterator is the end iterator.
textIterIsEnd :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>iter</tt></i> is the first iterator in
--   the buffer.
textIterIsStart :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Swaps the value of <i><tt>first</tt></i> and <i><tt>second</tt></i> if
--   <i><tt>second</tt></i> comes before <i><tt>first</tt></i> in the
--   buffer.
--   
--   That is, ensures that <i><tt>first</tt></i> and <i><tt>second</tt></i>
--   are in sequence. Most text buffer functions that take a range call
--   this automatically on your behalf, so there’s no real reason to call
--   it yourself in those cases. There are some exceptions, such as
--   <a>textIterInRange</a>, that expect a pre-sorted range.
textIterOrder :: (HasCallStack, MonadIO m) => TextIter -> TextIter -> m ()

-- | Moves iterator <i><tt>iter</tt></i> to the start of the line
--   <i><tt>lineNumber</tt></i>.
--   
--   If <i><tt>lineNumber</tt></i> is negative or larger than or equal to
--   the number of lines in the buffer, moves <i><tt>iter</tt></i> to the
--   start of the last line in the buffer.
textIterSetLine :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Same as <a>textIterSetLineOffset</a>, but works with a byte index. The
--   given byte index must be at the start of a character, it can’t be in
--   the middle of a UTF-8 encoded character.
textIterSetLineIndex :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Moves <i><tt>iter</tt></i> within a line, to a new character (not
--   byte) offset.
--   
--   The given character offset must be less than or equal to the number of
--   characters in the line; if equal, <i><tt>iter</tt></i> moves to the
--   start of the next line. See <a>textIterSetLineIndex</a> if you have a
--   byte index rather than a character offset.
textIterSetLineOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Sets <i><tt>iter</tt></i> to point to <i><tt>charOffset</tt></i>.
--   
--   <i><tt>charOffset</tt></i> counts from the start of the entire text
--   buffer, starting with 0.
textIterSetOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Like <a>textIterSetLineIndex</a>, but the index is in visible bytes,
--   i.e. text with a tag making it invisible is not counted in the index.
textIterSetVisibleLineIndex :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Like <a>textIterSetLineOffset</a>, but the offset is in visible
--   characters, i.e. text with a tag making it invisible is not counted in
--   the offset.
textIterSetVisibleLineOffset :: (HasCallStack, MonadIO m) => TextIter -> Int32 -> m ()

-- | Returns <a>True</a> if <i><tt>iter</tt></i> begins a paragraph.
--   
--   This is the case if <a>textIterGetLineOffset</a> would return 0.
--   However this function is potentially more efficient than
--   <a>textIterGetLineOffset</a>, because it doesn’t have to compute the
--   offset, it just has to see whether it’s 0.
textIterStartsLine :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Determines whether <i><tt>iter</tt></i> begins a sentence.
--   
--   Sentence boundaries are determined by Pango and should be correct for
--   nearly any language.
textIterStartsSentence :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Returns <a>True</a> if <i><tt>tag</tt></i> is toggled on at exactly
--   this point.
--   
--   If <i><tt>tag</tt></i> is <a>Nothing</a>, returns <a>True</a> if any
--   tag is toggled on at this point.
--   
--   Note that if this function returns <a>True</a>, it means that
--   <i><tt>iter</tt></i> is at the beginning of the tagged range, and that
--   the character at <i><tt>iter</tt></i> is inside the tagged range. In
--   other words, unlike <a>textIterEndsTag</a>, if this function returns
--   <a>True</a>, <a>textIterHasTag</a> will also return <a>True</a> for
--   the same parameters.
textIterStartsTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool

-- | Determines whether <i><tt>iter</tt></i> begins a natural-language
--   word.
--   
--   Word breaks are determined by Pango and should be correct for nearly
--   any language.
textIterStartsWord :: (HasCallStack, MonadIO m) => TextIter -> m Bool

-- | Gets whether a range with <i><tt>tag</tt></i> applied to it begins or
--   ends at <i><tt>iter</tt></i>.
--   
--   This is equivalent to (<a>textIterStartsTag</a> ||
--   <a>textIterEndsTag</a>)
textIterTogglesTag :: (HasCallStack, MonadIO m, IsTextTag a) => TextIter -> Maybe a -> m Bool
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.TextIter.TextIter tag
instance GHC.Classes.Eq GI.Gtk.Structs.TextIter.TextIter
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.TextIter.TextIter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.TextIter.TextIter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.TextIter.TextIter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.TextIter.TextIter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.TextIter.TextIter


-- | An auxiliary object for printing that allows decoupling the setup from
--   the printing.
--   
--   A print setup is obtained by calling <a>printDialogSetup</a>, and can
--   later be passed to print functions such as <a>printDialogPrint</a>.
--   
--   Print setups can be reused for multiple print calls.
--   
--   Applications may wish to store the page_setup and print_settings from
--   the print setup and copy them to the PrintDialog if they want to keep
--   using them.
--   
--   <i>Since: 4.14</i>
module GI.Gtk.Structs.PrintSetup

-- | Memory-managed wrapper type.
newtype PrintSetup
PrintSetup :: ManagedPtr PrintSetup -> PrintSetup

-- | Returns the page setup of <i><tt>setup</tt></i>.
--   
--   It may be different from the <tt>GtkPrintDialog</tt>'s page setup if
--   the user changed it during the setup process.
--   
--   <i>Since: 4.14</i>
printSetupGetPageSetup :: (HasCallStack, MonadIO m) => PrintSetup -> m PageSetup

-- | Returns the print settings of <i><tt>setup</tt></i>.
--   
--   They may be different from the <tt>GtkPrintDialog</tt>'s settings if
--   the user changed them during the setup process.
--   
--   <i>Since: 4.14</i>
printSetupGetPrintSettings :: (HasCallStack, MonadIO m) => PrintSetup -> m PrintSettings

-- | Increase the reference count of <i><tt>setup</tt></i>.
--   
--   <i>Since: 4.14</i>
printSetupRef :: (HasCallStack, MonadIO m) => PrintSetup -> m PrintSetup

-- | Decrease the reference count of <i><tt>setup</tt></i>.
--   
--   If the reference count reaches zero, the object is freed.
--   
--   <i>Since: 4.14</i>
printSetupUnref :: (HasCallStack, MonadIO m) => PrintSetup -> m ()
instance GHC.Classes.Eq GI.Gtk.Structs.PrintSetup.PrintSetup
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.PrintSetup.PrintSetup
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.PrintSetup.PrintSetup
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.PrintSetup.PrintSetup)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.PrintSetup.PrintSetup
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.PrintSetup.PrintSetup


-- | A sub-parser for <tt>GtkBuildable</tt> implementations.
module GI.Gtk.Structs.BuildableParser

-- | Memory-managed wrapper type.
newtype BuildableParser
BuildableParser :: ManagedPtr BuildableParser -> BuildableParser

-- | Construct a <a>BuildableParser</a> struct initialized to zero.
newZeroBuildableParser :: MonadIO m => m BuildableParser

-- | Set the value of the “<tt>end_element</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #endElement
--   </pre>
clearBuildableParserEndElement :: MonadIO m => BuildableParser -> m ()

-- | Get the value of the “<tt>end_element</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> buildableParser #endElement
--   </pre>
getBuildableParserEndElement :: MonadIO m => BuildableParser -> m (Maybe BuildableParserEndElementFieldCallback_WithClosures)

-- | Set the value of the “<tt>end_element</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> buildableParser [ #endElement <a>:=</a> value ]
--   </pre>
setBuildableParserEndElement :: MonadIO m => BuildableParser -> FunPtr C_BuildableParserEndElementFieldCallback -> m ()

-- | Set the value of the “<tt>error</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #error
--   </pre>
clearBuildableParserError :: MonadIO m => BuildableParser -> m ()

-- | Get the value of the “<tt>error</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> buildableParser #error
--   </pre>
getBuildableParserError :: MonadIO m => BuildableParser -> m (Maybe BuildableParserErrorFieldCallback_WithClosures)

-- | Set the value of the “<tt>error</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> buildableParser [ #error <a>:=</a> value ]
--   </pre>
setBuildableParserError :: MonadIO m => BuildableParser -> FunPtr C_BuildableParserErrorFieldCallback -> m ()

-- | Set the value of the “<tt>start_element</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #startElement
--   </pre>
clearBuildableParserStartElement :: MonadIO m => BuildableParser -> m ()

-- | Get the value of the “<tt>start_element</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> buildableParser #startElement
--   </pre>
getBuildableParserStartElement :: MonadIO m => BuildableParser -> m (Maybe BuildableParserStartElementFieldCallback_WithClosures)

-- | Set the value of the “<tt>start_element</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> buildableParser [ #startElement <a>:=</a> value ]
--   </pre>
setBuildableParserStartElement :: MonadIO m => BuildableParser -> FunPtr C_BuildableParserStartElementFieldCallback -> m ()

-- | Set the value of the “<tt>text</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearBuildableParserText :: MonadIO m => BuildableParser -> m ()

-- | Get the value of the “<tt>text</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> buildableParser #text
--   </pre>
getBuildableParserText :: MonadIO m => BuildableParser -> m (Maybe BuildableParserTextFieldCallback_WithClosures)

-- | Set the value of the “<tt>text</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> buildableParser [ #text <a>:=</a> value ]
--   </pre>
setBuildableParserText :: MonadIO m => BuildableParser -> FunPtr C_BuildableParserTextFieldCallback -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.BuildableParser.BuildableParser
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.BuildableParser.BuildableParser
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.BuildableParser.BuildableParser tag
instance GHC.Classes.Eq GI.Gtk.Structs.BuildableParser.BuildableParser
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.BuildableParser.BuildableParser


-- | Provides context for parsing GtkBuilder UI files.
--   
--   <tt>GtkBuildableParseContext</tt> is an opaque struct.
module GI.Gtk.Structs.BuildableParseContext

-- | Memory-managed wrapper type.
newtype BuildableParseContext
BuildableParseContext :: ManagedPtr BuildableParseContext -> BuildableParseContext

-- | Retrieves the name of the currently open element.
--   
--   If called from the start_element or end_element handlers this will
--   give the element_name as passed to those functions. For the parent
--   elements, see <a>buildableParseContextGetElementStack</a>.
buildableParseContextGetElement :: (HasCallStack, MonadIO m) => BuildableParseContext -> m (Maybe Text)

-- | Retrieves the element stack from the internal state of the parser.
--   
--   The returned <tt>GPtrArray</tt> is an array of strings where the last
--   item is the currently open tag (as would be returned by
--   <a>buildableParseContextGetElement</a>) and the previous item is its
--   immediate parent.
--   
--   This function is intended to be used in the start_element and
--   end_element handlers where <a>buildableParseContextGetElement</a>
--   would merely return the name of the element that is being processed.
buildableParseContextGetElementStack :: (HasCallStack, MonadIO m) => BuildableParseContext -> m [Text]

-- | Retrieves the current line number and the number of the character on
--   that line. Intended for use in error messages; there are no strict
--   semantics for what constitutes the "current" line number other than
--   "the best number we could come up with for error messages."
buildableParseContextGetPosition :: (HasCallStack, MonadIO m) => BuildableParseContext -> m (Int32, Int32)

-- | Completes the process of a temporary sub-parser redirection.
--   
--   This function exists to collect the user_data allocated by a matching
--   call to <a>buildableParseContextPush</a>. It must be called in the
--   end_element handler corresponding to the start_element handler during
--   which <a>buildableParseContextPush</a> was called. You must not call
--   this function from the error callback -- the <i><tt>userData</tt></i>
--   is provided directly to the callback in that case.
--   
--   This function is not intended to be directly called by users
--   interested in invoking subparsers. Instead, it is intended to be used
--   by the subparsers themselves to implement a higher-level interface.
buildableParseContextPop :: (HasCallStack, MonadIO m) => BuildableParseContext -> m (Ptr ())

-- | Temporarily redirects markup data to a sub-parser.
--   
--   This function may only be called from the start_element handler of a
--   <tt>GtkBuildableParser</tt>. It must be matched with a corresponding
--   call to <a>buildableParseContextPop</a> in the matching end_element
--   handler (except in the case that the parser aborts due to an error).
--   
--   All tags, text and other data between the matching tags is redirected
--   to the subparser given by <i><tt>parser</tt></i>.
--   <i><tt>userData</tt></i> is used as the user_data for that parser.
--   <i><tt>userData</tt></i> is also passed to the error callback in the
--   event that an error occurs. This includes errors that occur in
--   subparsers of the subparser.
--   
--   The end tag matching the start tag for which this call was made is
--   handled by the previous parser (which is given its own user_data)
--   which is why <a>buildableParseContextPop</a> is provided to allow "one
--   last access" to the <i><tt>userData</tt></i> provided to this
--   function. In the case of error, the <i><tt>userData</tt></i> provided
--   here is passed directly to the error callback of the subparser and
--   <a>buildableParseContextPop</a> should not be called. In either case,
--   if <i><tt>userData</tt></i> was allocated then it ought to be freed
--   from both of these locations.
--   
--   This function is not intended to be directly called by users
--   interested in invoking subparsers. Instead, it is intended to be used
--   by the subparsers themselves to implement a higher-level interface.
--   
--   For an example of how to use this, see <a>markupParseContextPush</a>
--   which has the same kind of API.
buildableParseContextPush :: (HasCallStack, MonadIO m) => BuildableParseContext -> BuildableParser -> Ptr () -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.BuildableParseContext.BuildableParseContext
instance GHC.Classes.Eq GI.Gtk.Structs.BuildableParseContext.BuildableParseContext
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.BuildableParseContext.BuildableParseContext


-- | Implements titlebar functionality for a window.
--   
--   When added into a window, it can be dragged to move the window, and it
--   implements the right click, double click and middle click behaviors
--   that are expected of a titlebar.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkWindowHandle</tt> has a single CSS node with the name
--   <tt>windowhandle</tt>.
--   
--   <h1>Accessibility</h1>
--   
--   Until GTK 4.10, <tt>GtkWindowHandle</tt> used the
--   <a>AccessibleRoleGroup</a> role.
--   
--   Starting from GTK 4.12, <tt>GtkWindowHandle</tt> uses the
--   <a>AccessibleRoleGeneric</a> role.
module GI.Gtk.Objects.WindowHandle

-- | Memory-managed wrapper type.
newtype WindowHandle
WindowHandle :: ManagedPtr WindowHandle -> WindowHandle

-- | Type class for types which can be safely cast to <a>WindowHandle</a>,
--   for instance with <a>toWindowHandle</a>.
class (GObject o, IsDescendantOf WindowHandle o) => IsWindowHandle o

-- | Cast to <a>WindowHandle</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toWindowHandle :: (MonadIO m, IsWindowHandle o) => o -> m WindowHandle

-- | Gets the child widget of <i><tt>self</tt></i>.
windowHandleGetChild :: (HasCallStack, MonadIO m, IsWindowHandle a) => a -> m (Maybe Widget)

-- | Creates a new <tt>GtkWindowHandle</tt>.
windowHandleNew :: (HasCallStack, MonadIO m) => m WindowHandle

-- | Sets the child widget of <i><tt>self</tt></i>.
windowHandleSetChild :: (HasCallStack, MonadIO m, IsWindowHandle a, IsWidget b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearWindowHandleChild :: (MonadIO m, IsWindowHandle o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowHandleChild :: (IsWindowHandle o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> windowHandle #child
--   </pre>
getWindowHandleChild :: (MonadIO m, IsWindowHandle o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> windowHandle [ #child <a>:=</a> value ]
--   </pre>
setWindowHandleChild :: (MonadIO m, IsWindowHandle o, IsWidget a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.WindowHandle.WindowHandle
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.WindowHandle.WindowHandle
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.WindowHandle.WindowHandle
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.WindowHandle.WindowHandle)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.WindowHandle.WindowHandle o) => GI.Gtk.Objects.WindowHandle.IsWindowHandle o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.WindowHandle.WindowHandle
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.WindowHandle.WindowHandle


-- | Creates groups of windows that behave like separate applications.
--   
--   It achieves this by limiting the effect of GTK grabs and modality to
--   windows in the same group.
--   
--   A window can be a member in at most one window group at a time.
--   Windows that have not been explicitly assigned to a group are
--   implicitly treated like windows of the default window group.
--   
--   <tt>GtkWindowGroup</tt> objects are referenced by each window in the
--   group, so once you have added all windows to a
--   <tt>GtkWindowGroup</tt>, you can drop the initial reference to the
--   window group with <a>objectUnref</a>. If the windows in the window
--   group are subsequently destroyed, then they will be removed from the
--   window group and drop their references on the window group; when all
--   window have been removed, the window group will be freed.
module GI.Gtk.Objects.WindowGroup

-- | Memory-managed wrapper type.
newtype WindowGroup
WindowGroup :: ManagedPtr WindowGroup -> WindowGroup

-- | Type class for types which can be safely cast to <a>WindowGroup</a>,
--   for instance with <a>toWindowGroup</a>.
class (GObject o, IsDescendantOf WindowGroup o) => IsWindowGroup o

-- | Cast to <a>WindowGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toWindowGroup :: (MonadIO m, IsWindowGroup o) => o -> m WindowGroup

-- | Adds a window to a <tt>GtkWindowGroup</tt>.
windowGroupAddWindow :: (HasCallStack, MonadIO m, IsWindowGroup a, IsWindow b) => a -> b -> m ()

-- | Returns a list of the <tt>GtkWindows</tt> that belong to
--   <i><tt>windowGroup</tt></i>.
windowGroupListWindows :: (HasCallStack, MonadIO m, IsWindowGroup a) => a -> m [Window]

-- | Creates a new <tt>GtkWindowGroup</tt> object.
--   
--   Modality of windows only affects windows within the same
--   <tt>GtkWindowGroup</tt>.
windowGroupNew :: (HasCallStack, MonadIO m) => m WindowGroup

-- | Removes a window from a <tt>GtkWindowGroup</tt>.
windowGroupRemoveWindow :: (HasCallStack, MonadIO m, IsWindowGroup a, IsWindow b) => a -> b -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.WindowGroup.WindowGroup
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.WindowGroup.WindowGroup
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.WindowGroup.WindowGroup
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.WindowGroup.WindowGroup)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.WindowGroup.WindowGroup o) => GI.Gtk.Objects.WindowGroup.IsWindowGroup o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.WindowGroup.WindowGroup
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.WindowGroup.WindowGroup


-- | Shows window frame controls.
--   
--   Typical window frame controls are minimize, maximize and close
--   buttons, and the window icon.
--   
--   &lt;picture&gt; &lt;source srcset="windowcontrols-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkWindowControls" src="windowcontrols.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkWindowControls</tt> only displays start or end side of the
--   controls (see <a>WindowControls:side</a>), so it's intended to be
--   always used in pair with another <tt>GtkWindowControls</tt> for the
--   opposite side, for example:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkBox"&gt;
--     &lt;child&gt;
--       &lt;object class="GtkWindowControls"&gt;
--         &lt;property name="side"&gt;start&lt;/property&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   
--     ...
--   
--     &lt;child&gt;
--       &lt;object class="GtkWindowControls"&gt;
--         &lt;property name="side"&gt;end&lt;/property&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   windowcontrols
--   ├── [image.icon]
--   ├── [button.minimize]
--   ├── [button.maximize]
--   ╰── [button.close]
--   </pre>
--   
--   A <tt>GtkWindowControls</tt>' CSS node is called windowcontrols. It
--   contains subnodes corresponding to each title button. Which of the
--   title buttons exist and where they are placed exactly depends on the
--   desktop environment and <a>WindowControls:decorationLayout</a> value.
--   
--   When <a>WindowControls:empty</a> is true, it gets the .empty style
--   class.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkWindowControls</tt> uses the <a>AccessibleRoleGroup</a> role.
module GI.Gtk.Objects.WindowControls

-- | Memory-managed wrapper type.
newtype WindowControls
WindowControls :: ManagedPtr WindowControls -> WindowControls

-- | Type class for types which can be safely cast to
--   <a>WindowControls</a>, for instance with <a>toWindowControls</a>.
class (GObject o, IsDescendantOf WindowControls o) => IsWindowControls o

-- | Cast to <a>WindowControls</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toWindowControls :: (MonadIO m, IsWindowControls o) => o -> m WindowControls

-- | Gets the decoration layout of this window controls widget
windowControlsGetDecorationLayout :: (HasCallStack, MonadIO m, IsWindowControls a) => a -> m (Maybe Text)

-- | Gets whether the widget has any window buttons.
windowControlsGetEmpty :: (HasCallStack, MonadIO m, IsWindowControls a) => a -> m Bool

-- | Gets the side to which this window controls widget belongs.
windowControlsGetSide :: (HasCallStack, MonadIO m, IsWindowControls a) => a -> m PackType

-- | Returns whether platform native window controls are shown.
--   
--   <i>Since: 4.18</i>
windowControlsGetUseNativeControls :: (HasCallStack, MonadIO m, IsWindowControls a) => a -> m Bool

-- | Creates a new <tt>GtkWindowControls</tt>.
windowControlsNew :: (HasCallStack, MonadIO m) => PackType -> m WindowControls

-- | Sets the decoration layout for the title buttons.
--   
--   This overrides the <a>Settings:gtkDecorationLayout</a> setting.
--   
--   The format of the string is button names, separated by commas. A colon
--   separates the buttons that should appear on the left from those on the
--   right. Recognized button names are minimize, maximize, close and icon
--   (the window icon).
--   
--   For example, “icon:minimize,maximize,close” specifies a icon on the
--   left, and minimize, maximize and close buttons on the right.
--   
--   If <a>WindowControls:side</a> value is <a>PackTypeStart</a>,
--   <i><tt>self</tt></i> will display the part before the colon, otherwise
--   after that.
windowControlsSetDecorationLayout :: (HasCallStack, MonadIO m, IsWindowControls a) => a -> Maybe Text -> m ()

-- | Determines which part of decoration layout the window controls widget
--   uses.
--   
--   See <a>WindowControls:decorationLayout</a>.
windowControlsSetSide :: (HasCallStack, MonadIO m, IsWindowControls a) => a -> PackType -> m ()

-- | Sets whether platform native window controls are used.
--   
--   This option shows the "stoplight" buttons on macOS. For Linux, this
--   option has no effect.
--   
--   See also <a>Using GTK on Apple macOS</a>.
--   
--   <i>Since: 4.18</i>
windowControlsSetUseNativeControls :: (HasCallStack, MonadIO m, IsWindowControls a) => a -> Bool -> m ()

-- | Set the value of the “<tt>decoration-layout</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #decorationLayout
--   </pre>
clearWindowControlsDecorationLayout :: (MonadIO m, IsWindowControls o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>decoration-layout</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowControlsDecorationLayout :: (IsWindowControls o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> windowControls #decorationLayout
--   </pre>
getWindowControlsDecorationLayout :: (MonadIO m, IsWindowControls o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> windowControls [ #decorationLayout <a>:=</a> value ]
--   </pre>
setWindowControlsDecorationLayout :: (MonadIO m, IsWindowControls o) => o -> Text -> m ()

-- | Get the value of the “<tt>empty</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> windowControls #empty
--   </pre>
getWindowControlsEmpty :: (MonadIO m, IsWindowControls o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>side</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowControlsSide :: (IsWindowControls o, MonadIO m) => PackType -> m (GValueConstruct o)

-- | Get the value of the “<tt>side</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> windowControls #side
--   </pre>
getWindowControlsSide :: (MonadIO m, IsWindowControls o) => o -> m PackType

-- | Set the value of the “<tt>side</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> windowControls [ #side <a>:=</a> value ]
--   </pre>
setWindowControlsSide :: (MonadIO m, IsWindowControls o) => o -> PackType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-native-controls</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructWindowControlsUseNativeControls :: (IsWindowControls o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-native-controls</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> windowControls #useNativeControls
--   </pre>
getWindowControlsUseNativeControls :: (MonadIO m, IsWindowControls o) => o -> m Bool

-- | Set the value of the “<tt>use-native-controls</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> windowControls [ #useNativeControls <a>:=</a> value ]
--   </pre>
setWindowControlsUseNativeControls :: (MonadIO m, IsWindowControls o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.WindowControls.WindowControls
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.WindowControls.WindowControls
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.WindowControls.WindowControls
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.WindowControls.WindowControls)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.WindowControls.WindowControls o) => GI.Gtk.Objects.WindowControls.IsWindowControls o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.WindowControls.WindowControls
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.WindowControls.WindowControls


-- | A toplevel window which can contain other widgets.
--   
--   &lt;picture&gt; &lt;source srcset="window-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkWindow" src="window.png"&gt; &lt;/picture&gt;
--   
--   Windows normally have decorations that are under the control of the
--   windowing system and allow the user to manipulate the window (resize
--   it, move it, close it,...).
--   
--   <h1>GtkWindow as GtkBuildable</h1>
--   
--   The <tt>GtkWindow</tt> implementation of the <a>Buildable</a>
--   interface supports setting a child as the titlebar by specifying
--   “titlebar” as the “type” attribute of a <tt>&lt;child&gt;</tt>
--   element.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkWindow</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;F10&lt;/kbd&gt; activates the menubar, if present.</li>
--   <li>&lt;kbd&gt;Alt&lt;/kbd&gt; makes the mnemonics visible while
--   pressed.</li>
--   </ul>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>Window::activateDefault</a></li>
--   <li><a>Window::activateFocus</a></li>
--   <li><a>Window::enableDebugging</a></li>
--   </ul>
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkWindow</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>default.activate</tt> activates the default widget.</li>
--   <li><tt>window.minimize</tt> minimizes the window.</li>
--   <li><tt>window.toggle-maximized</tt> maximizes or restores the
--   window.</li>
--   <li><tt>window.close</tt> closes the window.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   window.background [.csd / .solid-csd / .ssd] [.maximized / .fullscreen / .tiled]
--   ├── &lt;child&gt;
--   ╰── &lt;titlebar child&gt;.titlebar [.default-decoration]
--   </pre>
--   
--   <tt>GtkWindow</tt> has a main CSS node with name window and style
--   class .background.
--   
--   Style classes that are typically used with the main CSS node are .csd
--   (when client-side decorations are in use), .solid-csd (for client-side
--   decorations without invisible borders), .ssd (used by mutter when
--   rendering server-side decorations). GtkWindow also represents window
--   states with the following style classes on the main node: .maximized,
--   .fullscreen, .tiled (when supported, also .tiled-top, .tiled-left,
--   .tiled-right, .tiled-bottom).
--   
--   <tt>GtkWindow</tt> subclasses often add their own discriminating style
--   classes, such as .dialog, .popup or .tooltip.
--   
--   Generally, some CSS properties don't make sense on the toplevel window
--   node, such as margins or padding. When client-side decorations without
--   invisible borders are in use (i.e. the .solid-csd style class is added
--   to the main window node), the CSS border of the toplevel window is
--   used for resize drags. In the .csd case, the shadow area outside of
--   the window can be used to resize it.
--   
--   <tt>GtkWindow</tt> adds the .titlebar and .default-decoration style
--   classes to the widget that is added as a titlebar child.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkWindow</tt> uses the <a>AccessibleRoleWindow</a> role.
--   
--   From GTK 4.12 to 4.18, it used the <a>AccessibleRoleApplication</a>
--   role.
module GI.Gtk.Objects.Window

-- | Memory-managed wrapper type.
newtype Window
Window :: ManagedPtr Window -> Window

-- | Type class for types which can be safely cast to <a>Window</a>, for
--   instance with <a>toWindow</a>.
class (GObject o, IsDescendantOf Window o) => IsWindow o

-- | Cast to <a>Window</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toWindow :: (MonadIO m, IsWindow o) => o -> m Window

-- | Requests that the window is closed.
--   
--   This is similar to what happens when a window manager close button is
--   clicked.
--   
--   This function can be used with close buttons in custom titlebars.
windowClose :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Drops the internal reference GTK holds on toplevel windows.
windowDestroy :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to place the window in the fullscreen state.
--   
--   Note that you shouldn’t assume the window is definitely fullscreen
--   afterward, because other entities (e.g. the user or window manager)
--   unfullscreen it again, and not all window managers honor requests to
--   fullscreen windows.
--   
--   If a window is not explicitly fullscreened or unfullscreened before it
--   is shown, the initial state is at the window managers discretion.
--   
--   You can track the result of this operation via the
--   <a>Toplevel:state</a> property, or by listening to notifications of
--   the <a>Window:fullscreened</a> property.
windowFullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to place the window in the fullscreen state on the given monitor.
--   
--   Note that you shouldn't assume the window is definitely fullscreen
--   afterward, or that the windowing system allows fullscreen windows on
--   any given monitor.
--   
--   You can track the result of this operation via the
--   <a>Toplevel:state</a> property, or by listening to notifications of
--   the <a>Window:fullscreened</a> property.
windowFullscreenOnMonitor :: (HasCallStack, MonadIO m, IsWindow a, IsMonitor b) => a -> b -> m ()

-- | Gets the application object associated with the window.
windowGetApplication :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Application)

-- | Gets the child widget of the window.
windowGetChild :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Returns whether the window has been set to have decorations.
windowGetDecorated :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns the fallback icon name for windows.
--   
--   The returned string is owned by GTK and should not be modified. It is
--   only valid until the next call to <a>windowSetDefaultIconName</a>.
windowGetDefaultIconName :: (HasCallStack, MonadIO m) => m (Maybe Text)

-- | Gets the default size of the window.
--   
--   A value of 0 for the width or height indicates that a default size has
--   not been explicitly set for that dimension, so the “natural” size of
--   the window will be used.
--   
--   This function is the recommended way for
--   &lt;<a>https://developer.gnome.org/documentation/tutorials/save-state.html</a>
--   saving window state across restarts of applications&gt;.
windowGetDefaultSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)

-- | Returns the default widget for <i><tt>window</tt></i>.
windowGetDefaultWidget :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Returns whether the window has been set to have a close button.
windowGetDeletable :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window will be destroyed with its transient
--   parent.
windowGetDestroyWithParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the current focused widget within the window.
--   
--   Note that this is the widget that would have the focus if the toplevel
--   window focused; if the toplevel window is not focused then
--   <tt>gtk_widget_has_focus (widget)</tt> will not be false for the
--   widget.
windowGetFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Gets whether “focus rectangles” are supposed to be visible.
windowGetFocusVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns the gravity that is used when changing the window size
--   programmatically.
--   
--   <i>Since: 4.20</i>
windowGetGravity :: (HasCallStack, MonadIO m, IsWindow a) => a -> m WindowGravity

-- | Returns the group for the window.
--   
--   If the window has no group, then the default group is returned.
windowGetGroup :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> m WindowGroup

-- | Returns whether this window reacts to &lt;kbd&gt;F10&lt;/kbd&gt;
--   presses by activating a menubar it contains.
--   
--   <i>Since: 4.2</i>
windowGetHandleMenubarAccel :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window will be hidden instead of destroyed when
--   the close button is clicked.
windowGetHideOnClose :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns the name of the themed icon for the window.
windowGetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Gets whether mnemonics are supposed to be visible.
windowGetMnemonicsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window is modal.
windowGetModal :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Gets whether the user can resize the window.
windowGetResizable :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the title of the window.
windowGetTitle :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Text)

-- | Returns the titlebar that has been set with <a>windowSetTitlebar</a>.
windowGetTitlebar :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Widget)

-- | Returns the list of all existing toplevel windows.
--   
--   If you want to iterate through the list and perform actions involving
--   callbacks that might destroy the widgets or add new ones, be aware
--   that the list of toplevels will change and emit the "items-changed"
--   signal.
windowGetToplevels :: (HasCallStack, MonadIO m) => m ListModel

-- | Fetches the transient parent for this window.
windowGetTransientFor :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Window)

-- | Returns whether the window has an explicit window group.
windowHasGroup :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns whether the window is part of the current active toplevel.
--   
--   The active toplevel is the window receiving keystrokes.
--   
--   The return value is <a>True</a> if the window is active toplevel
--   itself. You might use this function if you wanted to draw a widget
--   differently in an active window from a widget in an inactive window.
windowIsActive :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the current fullscreen state of the window.
--   
--   Note that since fullscreening is ultimately handled by the window
--   manager and happens asynchronously to an application request, you
--   shouldn’t assume the return value of this function changing
--   immediately (or at all), as an effect of calling
--   <a>windowFullscreen</a> or <a>windowUnfullscreen</a>.
--   
--   If the window isn't yet mapped, the value returned will whether the
--   initial requested state is fullscreen.
windowIsFullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the current maximized state of the window.
--   
--   Note that since maximization is ultimately handled by the window
--   manager and happens asynchronously to an application request, you
--   shouldn’t assume the return value of this function changing
--   immediately (or at all), as an effect of calling <a>windowMaximize</a>
--   or <a>windowUnmaximize</a>.
--   
--   If the window isn't yet mapped, the value returned will whether the
--   initial requested state is maximized.
windowIsMaximized :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Retrieves the current suspended state of the window.
--   
--   A window being suspended means it's currently not visible to the user,
--   for example by being on a inactive workspace, minimized, obstructed.
--   
--   <i>Since: 4.12</i>
windowIsSuspended :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool

-- | Returns the list of all existing toplevel windows.
--   
--   The widgets in the list are not individually referenced. If you want
--   to iterate through the list and perform actions involving callbacks
--   that might destroy the widgets, you must call <tt>g_list_foreach
--   (result, (GFunc)g_object_ref, NULL)</tt> first, and then unref all the
--   widgets afterwards.
windowListToplevels :: (HasCallStack, MonadIO m) => m [Widget]

-- | Asks to maximize the window, so that it fills the screen.
--   
--   Note that you shouldn’t assume the window is definitely maximized
--   afterward, because other entities (e.g. the user or window manager)
--   could unmaximize it again, and not all window managers support
--   maximization.
--   
--   It’s permitted to call this function before showing a window, in which
--   case the window will be maximized when it appears onscreen initially.
--   
--   If a window is not explicitly maximized or unmaximized before it is
--   shown, the initial state is at the window managers discretion. For
--   example, it might decide to maximize a window that almost fills the
--   screen.
--   
--   You can track the result of this operation via the
--   <a>Toplevel:state</a> property, or by listening to notifications on
--   the <a>Window:maximized</a> property.
windowMaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to minimize the window.
--   
--   Note that you shouldn’t assume the window is definitely minimized
--   afterward, because the windowing system might not support this
--   functionality; other entities (e.g. the user or the window manager)
--   could unminimize it again, or there may not be a window manager in
--   which case minimization isn’t possible, etc.
--   
--   It’s permitted to call this function before showing a window, in which
--   case the window will be minimized before it ever appears onscreen.
--   
--   You can track result of this operation via the <a>Toplevel:state</a>
--   property.
windowMinimize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Creates a new <tt>GtkWindow</tt>.
--   
--   To get an undecorated window (without window borders), use
--   <a>windowSetDecorated</a>.
--   
--   All top-level windows created by this function are stored in an
--   internal top-level window list. This list can be obtained from
--   <a>windowListToplevels</a>. Due to GTK keeping a reference to the
--   window internally, this function does not return a reference to the
--   caller.
--   
--   To delete a <tt>GtkWindow</tt>, call <a>windowDestroy</a>.
windowNew :: (HasCallStack, MonadIO m) => m Window

-- | Presents a window to the user.
--   
--   This may mean raising the window in the stacking order, unminimizing
--   it, moving it to the current desktop and/or giving it the keyboard
--   focus (possibly dependent on the user’s platform, window manager and
--   preferences).
--   
--   If <i><tt>window</tt></i> is hidden, this function also makes it
--   visible.
windowPresent :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Presents a window to the user in response to an user interaction.
--   
--   See <a>windowPresent</a> for more details.
--   
--   The timestamp should be gathered when the window was requested to be
--   shown (when clicking a link for example), rather than once the window
--   is ready to be shown.

-- | <i>Deprecated: (Since version 4.14)Use <a>windowPresent</a></i>
windowPresentWithTime :: (HasCallStack, MonadIO m, IsWindow a) => a -> Word32 -> m ()

-- | Sets or unsets the application object associated with the window.
--   
--   The application will be kept alive for at least as long as it has any
--   windows associated with it (see <a>applicationHold</a> for a way to
--   keep it alive without windows).
--   
--   Normally, the connection between the application and the window will
--   remain until the window is destroyed, but you can explicitly remove it
--   by setting the <i><tt>application</tt></i> to <a>Nothing</a>.
--   
--   This is equivalent to calling <a>applicationRemoveWindow</a> and/or
--   <a>applicationAddWindow</a> on the old/new applications as relevant.
windowSetApplication :: (HasCallStack, MonadIO m, IsWindow a, IsApplication b) => a -> Maybe b -> m ()

-- | Sets whether the window should request startup notification.
--   
--   By default, after showing the first window, GTK calls
--   <a>toplevelSetStartupId</a>. Call this function to disable the
--   automatic startup notification. You might do this if your first window
--   is a splash screen, and you want to delay notification until after
--   your real main window has been shown, for example.
--   
--   In that example, you would disable startup notification temporarily,
--   show your splash screen, then re-enable it so that showing the main
--   window would automatically result in notification.
windowSetAutoStartupNotification :: (HasCallStack, MonadIO m) => Bool -> m ()

-- | Sets the child widget of the window.
windowSetChild :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the window should be decorated.
--   
--   By default, windows are decorated with a title bar, resize controls,
--   etc. Some window managers allow GTK to disable these decorations,
--   creating a borderless window. If you set the decorated property to
--   false using this function, GTK will do its best to convince the window
--   manager not to decorate the window. Depending on the system, this
--   function may not have any effect when called on a window that is
--   already visible, so you should call it before calling
--   <a>widgetShow</a>.
--   
--   On Windows, this function always works, since there’s no window
--   manager policy involved.
windowSetDecorated :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets an icon to be used as fallback.
--   
--   The fallback icon is used for windows that haven't had
--   <a>windowSetIconName</a> called on them.
windowSetDefaultIconName :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Sets the default size of a window.
--   
--   The default size of a window is the size that will be used if no other
--   constraints apply.
--   
--   The default size will be updated whenever the window is resized to
--   reflect the new size, unless the window is forced to a size, like when
--   it is maximized or fullscreened.
--   
--   If the window’s minimum size request is larger than the default, the
--   default will be ignored.
--   
--   Setting the default size to a value &lt;= 0 will cause it to be
--   ignored and the natural size request will be used instead. It is
--   possible to do this while the window is showing to "reset" it to its
--   initial size.
--   
--   Unlike <a>widgetSetSizeRequest</a>, which sets a size request for a
--   widget and thus would keep users from shrinking the window, this
--   function only sets the initial size, just as if the user had resized
--   the window themselves. Users can still shrink the window again as they
--   normally would. Setting a default size of -1 means to use the
--   “natural” default size (the size request of the window).
--   
--   If you use this function to reestablish a previously saved window
--   size, note that the appropriate size to save is the one returned by
--   <a>windowGetDefaultSize</a>. Using the window allocation directly will
--   not work in all circumstances and can lead to growing or shrinking
--   windows.
windowSetDefaultSize :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()

-- | Sets the default widget.
--   
--   The default widget is the widget that is activated when the user
--   presses &lt;kbd&gt;Enter&lt;/kbd&gt; in a dialog (for example).
windowSetDefaultWidget :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the window should be deletable.
--   
--   By default, windows have a close button in the window frame. Some
--   window managers allow GTK to disable this button. If you set the
--   deletable property to false using this function, GTK will do its best
--   to convince the window manager not to show a close button. Depending
--   on the system, this function may not have any effect when called on a
--   window that is already visible, so you should call it before calling
--   <a>widgetShow</a>.
--   
--   On Windows, this function always works, since there’s no window
--   manager policy involved.
windowSetDeletable :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets whether to destroy the window when the transient parent is
--   destroyed.
--   
--   This is useful for dialogs that shouldn’t persist beyond the lifetime
--   of the main window they are associated with, for example.
windowSetDestroyWithParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets the display where the window is displayed.
--   
--   If the window is already mapped, it will be unmapped, and then
--   remapped on the new display.
windowSetDisplay :: (HasCallStack, MonadIO m, IsWindow a, IsDisplay b) => a -> b -> m ()

-- | Sets the focus widget.
--   
--   If <i><tt>focus</tt></i> is not the current focus widget, and is
--   focusable, sets it as the focus widget for the window. If
--   <i><tt>focus</tt></i> is <a>Nothing</a>, unsets the focus widget for
--   this window. To set the focus to a particular widget in the toplevel,
--   it is usually more convenient to use <a>widgetGrabFocus</a> instead of
--   this function.
windowSetFocus :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether “focus rectangles” are supposed to be visible.
--   
--   This property is maintained by GTK based on user input, and should not
--   be set by applications.
windowSetFocusVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets the gravity that is used when changing the window size
--   programmatically.
--   
--   <i>Since: 4.20</i>
windowSetGravity :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowGravity -> m ()

-- | Sets whether this window should react to &lt;kbd&gt;F10&lt;/kbd&gt;
--   presses by activating a menubar it contains.
--   
--   <i>Since: 4.2</i>
windowSetHandleMenubarAccel :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets whether clicking the close button will hide the window instead of
--   destroying it.
windowSetHideOnClose :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets the icon for the window from a named themed icon.
--   
--   See the docs for <a>IconTheme</a> for more details. On some platforms,
--   the window icon is not used at all.
--   
--   Note that this has nothing to do with the WM_ICON_NAME property which
--   is mentioned in the ICCCM.
windowSetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Text -> m ()

-- | Opens or closes the <a>interactive debugger</a>.
--   
--   The debugger offers access to the widget hierarchy of the application
--   and to useful debugging tools.
--   
--   This function allows applications that already use
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;I&lt;/kbd&gt;
--   (or
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;D&lt;/kbd&gt;)
--   for their own key shortcuts to add a different shortcut to open the
--   Inspector.
--   
--   If you are not overriding the default key shortcuts for the Inspector,
--   you should not use this function.
windowSetInteractiveDebugging :: (HasCallStack, MonadIO m) => Bool -> m ()

-- | Sets whether mnemonics are supposed to be visible.
--   
--   This property is maintained by GTK based on user input, and should not
--   be set by applications.
windowSetMnemonicsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets a window modal or non-modal.
--   
--   Modal windows prevent interaction with other windows in the same
--   application. To keep modal dialogs on top of main application windows,
--   use <a>windowSetTransientFor</a> to make the dialog transient for the
--   parent; most window managers will then disallow lowering the dialog
--   below the parent.
windowSetModal :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets whether the user can resize a window.
--   
--   Windows are user resizable by default.
windowSetResizable :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()

-- | Sets the startup notification ID.
--   
--   Startup notification identifiers are used by desktop environment to
--   track application startup, to provide user feedback and other
--   features. This function changes the corresponding property on the
--   underlying <tt>GdkSurface</tt>.
--   
--   Normally, startup identifier is managed automatically and you should
--   only use this function in special cases like transferring focus from
--   other processes. You should use this function before calling
--   <a>windowPresent</a> or any equivalent function generating a window
--   map event.
--   
--   This function is only useful on Wayland or X11, not with other GDK
--   backends.
windowSetStartupId :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()

-- | Sets the title of the window.
--   
--   The title of a window will be displayed in its title bar; on the X
--   Window System, the title bar is rendered by the window manager so
--   exactly how the title appears to users may vary according to a user’s
--   exact configuration. The title should help a user distinguish this
--   window from other windows they may have open. A good title might
--   include the application name and current document filename, for
--   example.
--   
--   Passing <tt>NULL</tt> does the same as setting the title to an empty
--   string.
windowSetTitle :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Text -> m ()

-- | Sets a custom titlebar for the window.
--   
--   A typical widget used here is <a>HeaderBar</a>, as it provides various
--   features expected of a titlebar while allowing the addition of child
--   widgets to it.
--   
--   If you set a custom titlebar, GTK will do its best to convince the
--   window manager not to put its own titlebar on the window. Depending on
--   the system, this function may not work for a window that is already
--   visible, so you set the titlebar before calling <a>widgetShow</a>.
windowSetTitlebar :: (HasCallStack, MonadIO m, IsWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets a transient parent for the window.
--   
--   Dialog windows should be set transient for the main application window
--   they were spawned from. This allows window managers to e.g. keep the
--   dialog on top of the main window, or center the dialog over the main
--   window. <a>Dialog</a>.<tt><i>new_with_buttons</i></tt>() and other
--   convenience functions in GTK will sometimes call this function on your
--   behalf.
--   
--   Passing <tt>NULL</tt> for <i><tt>parent</tt></i> unsets the current
--   transient window.
--   
--   On Windows, this function puts the child window on top of the parent,
--   much as the window manager would have done on X.
windowSetTransientFor :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> Maybe b -> m ()

-- | Asks to remove the fullscreen state for the window, and return to its
--   previous state.
--   
--   Note that you shouldn’t assume the window is definitely not fullscreen
--   afterward, because other entities (e.g. the user or window manager)
--   could fullscreen it again, and not all window managers honor requests
--   to unfullscreen windows; normally the window will end up restored to
--   its normal state. Just don’t write code that crashes if not.
--   
--   If a window is not explicitly fullscreened or unfullscreened before it
--   is shown, the initial state is at the window managers discretion.
--   
--   You can track the result of this operation via the
--   <a>Toplevel:state</a> property, or by listening to notifications of
--   the <a>Window:fullscreened</a> property.
windowUnfullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to unmaximize the window.
--   
--   Note that you shouldn’t assume the window is definitely unmaximized
--   afterward, because other entities (e.g. the user or window manager)
--   maximize it again, and not all window managers honor requests to
--   unmaximize.
--   
--   If a window is not explicitly maximized or unmaximized before it is
--   shown, the initial state is at the window managers discretion. For
--   example, it might decide to maximize a window that almost fills the
--   screen.
--   
--   You can track the result of this operation via the
--   <a>Toplevel:state</a> property, or by listening to notifications on
--   the <a>Window:maximized</a> property.
windowUnmaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Asks to unminimize the window.
--   
--   Note that you shouldn’t assume the window is definitely unminimized
--   afterward, because the windowing system might not support this
--   functionality; other entities (e.g. the user or the window manager)
--   could minimize it again, or there may not be a window manager in which
--   case minimization isn’t possible, etc.
--   
--   You can track result of this operation via the <a>Toplevel:state</a>
--   property.
windowUnminimize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()

-- | Set the value of the “<tt>application</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #application
--   </pre>
clearWindowApplication :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>application</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowApplication :: (IsWindow o, MonadIO m, IsApplication a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>application</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #application
--   </pre>
getWindowApplication :: (MonadIO m, IsWindow o) => o -> m (Maybe Application)

-- | Set the value of the “<tt>application</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #application <a>:=</a> value ]
--   </pre>
setWindowApplication :: (MonadIO m, IsWindow o, IsApplication a) => o -> a -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearWindowChild :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowChild :: (IsWindow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #child
--   </pre>
getWindowChild :: (MonadIO m, IsWindow o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #child <a>:=</a> value ]
--   </pre>
setWindowChild :: (MonadIO m, IsWindow o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>decorated</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowDecorated :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>decorated</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #decorated
--   </pre>
getWindowDecorated :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>decorated</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #decorated <a>:=</a> value ]
--   </pre>
setWindowDecorated :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-height</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowDefaultHeight :: (IsWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #defaultHeight
--   </pre>
getWindowDefaultHeight :: (MonadIO m, IsWindow o) => o -> m Int32

-- | Set the value of the “<tt>default-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #defaultHeight <a>:=</a> value ]
--   </pre>
setWindowDefaultHeight :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>default-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #defaultWidget
--   </pre>
clearWindowDefaultWidget :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-widget</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowDefaultWidget :: (IsWindow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #defaultWidget
--   </pre>
getWindowDefaultWidget :: (MonadIO m, IsWindow o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>default-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #defaultWidget <a>:=</a> value ]
--   </pre>
setWindowDefaultWidget :: (MonadIO m, IsWindow o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-width</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowDefaultWidth :: (IsWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #defaultWidth
--   </pre>
getWindowDefaultWidth :: (MonadIO m, IsWindow o) => o -> m Int32

-- | Set the value of the “<tt>default-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #defaultWidth <a>:=</a> value ]
--   </pre>
setWindowDefaultWidth :: (MonadIO m, IsWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>deletable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowDeletable :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>deletable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #deletable
--   </pre>
getWindowDeletable :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>deletable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #deletable <a>:=</a> value ]
--   </pre>
setWindowDeletable :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>destroy-with-parent</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructWindowDestroyWithParent :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>destroy-with-parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #destroyWithParent
--   </pre>
getWindowDestroyWithParent :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>destroy-with-parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #destroyWithParent <a>:=</a> value ]
--   </pre>
setWindowDestroyWithParent :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>display</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowDisplay :: (IsWindow o, MonadIO m, IsDisplay a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #display
--   </pre>
getWindowDisplay :: (MonadIO m, IsWindow o) => o -> m (Maybe Display)

-- | Set the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #display <a>:=</a> value ]
--   </pre>
setWindowDisplay :: (MonadIO m, IsWindow o, IsDisplay a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-visible</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowFocusVisible :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focus-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #focusVisible
--   </pre>
getWindowFocusVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>focus-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #focusVisible <a>:=</a> value ]
--   </pre>
setWindowFocusVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Set the value of the “<tt>focus-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #focusWidget
--   </pre>
clearWindowFocusWidget :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowFocusWidget :: (IsWindow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>focus-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #focusWidget
--   </pre>
getWindowFocusWidget :: (MonadIO m, IsWindow o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>focus-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #focusWidget <a>:=</a> value ]
--   </pre>
setWindowFocusWidget :: (MonadIO m, IsWindow o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fullscreened</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowFullscreened :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fullscreened</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #fullscreened
--   </pre>
getWindowFullscreened :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>fullscreened</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #fullscreened <a>:=</a> value ]
--   </pre>
setWindowFullscreened :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gravity</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowGravity :: (IsWindow o, MonadIO m) => WindowGravity -> m (GValueConstruct o)

-- | Get the value of the “<tt>gravity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #gravity
--   </pre>
getWindowGravity :: (MonadIO m, IsWindow o) => o -> m WindowGravity

-- | Set the value of the “<tt>gravity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #gravity <a>:=</a> value ]
--   </pre>
setWindowGravity :: (MonadIO m, IsWindow o) => o -> WindowGravity -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>handle-menubar-accel</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructWindowHandleMenubarAccel :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>handle-menubar-accel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #handleMenubarAccel
--   </pre>
getWindowHandleMenubarAccel :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>handle-menubar-accel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #handleMenubarAccel <a>:=</a> value ]
--   </pre>
setWindowHandleMenubarAccel :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hide-on-close</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowHideOnClose :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hide-on-close</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #hideOnClose
--   </pre>
getWindowHideOnClose :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>hide-on-close</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #hideOnClose <a>:=</a> value ]
--   </pre>
setWindowHideOnClose :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearWindowIconName :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowIconName :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #iconName
--   </pre>
getWindowIconName :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #iconName <a>:=</a> value ]
--   </pre>
setWindowIconName :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Get the value of the “<tt>is-active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #isActive
--   </pre>
getWindowIsActive :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>maximized</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowMaximized :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>maximized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #maximized
--   </pre>
getWindowMaximized :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>maximized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #maximized <a>:=</a> value ]
--   </pre>
setWindowMaximized :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mnemonics-visible</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWindowMnemonicsVisible :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>mnemonics-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #mnemonicsVisible
--   </pre>
getWindowMnemonicsVisible :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>mnemonics-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #mnemonicsVisible <a>:=</a> value ]
--   </pre>
setWindowMnemonicsVisible :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowModal :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #modal
--   </pre>
getWindowModal :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #modal <a>:=</a> value ]
--   </pre>
setWindowModal :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resizable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowResizable :: (IsWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #resizable
--   </pre>
getWindowResizable :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #resizable <a>:=</a> value ]
--   </pre>
setWindowResizable :: (MonadIO m, IsWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>startup-id</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowStartupId :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>startup-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #startupId <a>:=</a> value ]
--   </pre>
setWindowStartupId :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Get the value of the “<tt>suspended</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #suspended
--   </pre>
getWindowSuspended :: (MonadIO m, IsWindow o) => o -> m Bool

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearWindowTitle :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWindowTitle :: (IsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #title
--   </pre>
getWindowTitle :: (MonadIO m, IsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #title <a>:=</a> value ]
--   </pre>
setWindowTitle :: (MonadIO m, IsWindow o) => o -> Text -> m ()

-- | Set the value of the “<tt>titlebar</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #titlebar
--   </pre>
clearWindowTitlebar :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>titlebar</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWindowTitlebar :: (IsWindow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>titlebar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #titlebar
--   </pre>
getWindowTitlebar :: (MonadIO m, IsWindow o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>titlebar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #titlebar <a>:=</a> value ]
--   </pre>
setWindowTitlebar :: (MonadIO m, IsWindow o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>transient-for</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #transientFor
--   </pre>
clearWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transient-for</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWindowTransientFor :: (IsWindow o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> window #transientFor
--   </pre>
getWindowTransientFor :: (MonadIO m, IsWindow o) => o -> m (Maybe Window)

-- | Set the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> window [ #transientFor <a>:=</a> value ]
--   </pre>
setWindowTransientFor :: (MonadIO m, IsWindow o, IsWindow a) => o -> a -> m ()

-- | Emitted when the user activates the default widget.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The keybindings for this signal are all forms of the
--   &lt;kbd&gt;Enter&lt;/kbd&gt; key.
type WindowActivateDefaultCallback = IO ()

-- | Connect a signal handler for the <a>activateDefault</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> window #activateDefault callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateDefault</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> window #activateDefault callback
--   </pre>
onWindowActivateDefault :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateDefaultCallback) -> m SignalHandlerId

-- | Emitted when the user activates the currently focused widget of
--   <i><tt>window</tt></i>.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;␣&lt;/kbd&gt;.
type WindowActivateFocusCallback = IO ()

-- | Connect a signal handler for the <a>activateFocus</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> window #activateFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateFocus</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> window #activateFocus callback
--   </pre>
onWindowActivateFocus :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowActivateFocusCallback) -> m SignalHandlerId

-- | Emitted when the user clicks on the close button of the window.
type WindowCloseRequestCallback = IO Bool

-- | Connect a signal handler for the <a>closeRequest</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> window #closeRequest callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowCloseRequest :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCloseRequestCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>closeRequest</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> window #closeRequest callback
--   </pre>
onWindowCloseRequest :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCloseRequestCallback) -> m SignalHandlerId

-- | Emitted when the user enables or disables interactive debugging.
--   
--   When <i><tt>toggle</tt></i> is true, interactive debugging is toggled
--   on or off, when it is false, the debugger will be pointed at the
--   widget under the pointer.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;I&lt;/kbd&gt;
--   and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;D&lt;/kbd&gt;.
type WindowEnableDebuggingCallback = Bool -> IO Bool

-- | Connect a signal handler for the <a>enableDebugging</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> window #enableDebugging callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enableDebugging</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> window #enableDebugging callback
--   </pre>
onWindowEnableDebugging :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowEnableDebuggingCallback) -> m SignalHandlerId

-- | Emitted when the set of accelerators or mnemonics that are associated
--   with the window changes.

-- | <i>Deprecated: (Since version 4.10)Use <a>Shortcut</a> and
--   <a>EventController</a>to implement keyboard shortcuts</i>
type WindowKeysChangedCallback = IO ()

-- | Connect a signal handler for the <a>keysChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> window #keysChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keysChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> window #keysChanged callback
--   </pre>
onWindowKeysChanged :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowKeysChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Window.Window
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Window.Window
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Window.Window
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Window.Window)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Window.Window o) => GI.Gtk.Objects.Window.IsWindow o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Window.Window
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Window.Window


-- | A <tt>GdkPaintable</tt> that displays the contents of a widget.
--   
--   <tt>GtkWidgetPaintable</tt> will also take care of the widget not
--   being in a state where it can be drawn (like when it isn't shown) and
--   just draw nothing or where it does not have a size (like when it is
--   hidden) and report no size in that case.
--   
--   Of course, <tt>GtkWidgetPaintable</tt> allows you to monitor widgets
--   for size changes by emitting the <a>Paintable::invalidateSize</a>
--   signal whenever the size of the widget changes as well as for visual
--   changes by emitting the <a>Paintable::invalidateContents</a> signal
--   whenever the widget changes.
--   
--   You can use a <tt>GtkWidgetPaintable</tt> everywhere a
--   <tt>GdkPaintable</tt> is allowed, including using it on a
--   <tt>GtkPicture</tt> (or one of its parents) that it was set on itself
--   via <a>pictureSetPaintable</a>. The paintable will take care of
--   recursion when this happens. If you do this however, ensure that the
--   <a>Picture:canShrink</a> property is set to <a>True</a> or you might
--   end up with an infinitely growing widget.
module GI.Gtk.Objects.WidgetPaintable

-- | Memory-managed wrapper type.
newtype WidgetPaintable
WidgetPaintable :: ManagedPtr WidgetPaintable -> WidgetPaintable

-- | Type class for types which can be safely cast to
--   <a>WidgetPaintable</a>, for instance with <a>toWidgetPaintable</a>.
class (GObject o, IsDescendantOf WidgetPaintable o) => IsWidgetPaintable o

-- | Cast to <a>WidgetPaintable</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toWidgetPaintable :: (MonadIO m, IsWidgetPaintable o) => o -> m WidgetPaintable

-- | Returns the widget that is observed or <a>Nothing</a> if none.
widgetPaintableGetWidget :: (HasCallStack, MonadIO m, IsWidgetPaintable a) => a -> m (Maybe Widget)

-- | Creates a new widget paintable observing the given widget.
widgetPaintableNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> m WidgetPaintable

-- | Sets the widget that should be observed.
widgetPaintableSetWidget :: (HasCallStack, MonadIO m, IsWidgetPaintable a, IsWidget b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>widget</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #widget
--   </pre>
clearWidgetPaintableWidget :: (MonadIO m, IsWidgetPaintable o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>widget</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetPaintableWidget :: (IsWidgetPaintable o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetPaintable #widget
--   </pre>
getWidgetPaintableWidget :: (MonadIO m, IsWidgetPaintable o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetPaintable [ #widget <a>:=</a> value ]
--   </pre>
setWidgetPaintableWidget :: (MonadIO m, IsWidgetPaintable o, IsWidget a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.WidgetPaintable.WidgetPaintable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.WidgetPaintable.WidgetPaintable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.WidgetPaintable.WidgetPaintable
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.WidgetPaintable.WidgetPaintable)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.WidgetPaintable.WidgetPaintable o) => GI.Gtk.Objects.WidgetPaintable.IsWidgetPaintable o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.WidgetPaintable.WidgetPaintable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.WidgetPaintable.WidgetPaintable


-- | The base class for all widgets.
--   
--   It manages the widget lifecycle, layout, states and style.
--   
--   <h3>Height-for-width Geometry Management</h3>
--   
--   GTK uses a height-for-width (and width-for-height) geometry management
--   system. Height-for-width means that a widget can change how much
--   vertical space it needs, depending on the amount of horizontal space
--   that it is given (and similar for width-for-height). The most common
--   example is a label that reflows to fill up the available width, wraps
--   to fewer lines, and therefore needs less height.
--   
--   Height-for-width geometry management is implemented in GTK by way of
--   two virtual methods:
--   
--   <ul>
--   <li><a>Widget</a>.<tt><i>get_request_mode</i></tt>()</li>
--   <li><a>Widget</a>.<tt><i>measure</i></tt>()</li>
--   </ul>
--   
--   There are some important things to keep in mind when implementing
--   height-for-width and when using it in widget implementations.
--   
--   If you implement a direct <tt>GtkWidget</tt> subclass that supports
--   height-for-width or width-for-height geometry management for itself or
--   its child widgets, the
--   <a>Widget</a>.<tt><i>get_request_mode</i></tt>() virtual function must
--   be implemented as well and return the widget's preferred request mode.
--   The default implementation of this virtual function returns
--   <a>SizeRequestModeConstantSize</a>, which means that the widget will
--   only ever get -1 passed as the for_size value to its
--   <a>Widget</a>.<tt><i>measure</i></tt>() implementation.
--   
--   The geometry management system will query a widget hierarchy in only
--   one orientation at a time. When widgets are initially queried for
--   their minimum sizes it is generally done in two initial passes in the
--   <a>SizeRequestMode</a> chosen by the toplevel.
--   
--   For example, when queried in the normal
--   <a>SizeRequestModeHeightForWidth</a> mode:
--   
--   First, the default minimum and natural width for each widget in the
--   interface will be computed using <a>widgetMeasure</a> with an
--   orientation of <a>OrientationHorizontal</a> and a for_size of -1.
--   Because the preferred widths for each widget depend on the preferred
--   widths of their children, this information propagates up the
--   hierarchy, and finally a minimum and natural width is determined for
--   the entire toplevel. Next, the toplevel will use the minimum width to
--   query for the minimum height contextual to that width using
--   <a>widgetMeasure</a> with an orientation of <a>OrientationVertical</a>
--   and a for_size of the just computed width. This will also be a highly
--   recursive operation. The minimum height for the minimum width is
--   normally used to set the minimum size constraint on the toplevel.
--   
--   After the toplevel window has initially requested its size in both
--   dimensions it can go on to allocate itself a reasonable size (or a
--   size previously specified with <a>windowSetDefaultSize</a>). During
--   the recursive allocation process it’s important to note that request
--   cycles will be recursively executed while widgets allocate their
--   children. Each widget, once allocated a size, will go on to first
--   share the space in one orientation among its children and then request
--   each child's height for its target allocated width or its width for
--   allocated height, depending. In this way a widget will typically be
--   requested its size a number of times before actually being allocated a
--   size. The size a widget is finally allocated can of course differ from
--   the size it has requested. For this reason, <tt>GtkWidget</tt> caches
--   a small number of results to avoid re-querying for the same sizes in
--   one allocation cycle.
--   
--   If a widget does move content around to intelligently use up the
--   allocated size then it must support the request in both
--   <tt>GtkSizeRequestMode</tt>s even if the widget in question only
--   trades sizes in a single orientation.
--   
--   For instance, a <a>Label</a> that does height-for-width word wrapping
--   will not expect to have <a>Widget</a>.<tt><i>measure</i></tt>() with
--   an orientation of <a>OrientationVertical</a> called because that call
--   is specific to a width-for-height request. In this case the label must
--   return the height required for its own minimum possible width. By
--   following this rule any widget that handles height-for-width or
--   width-for-height requests will always be allocated at least enough
--   space to fit its own content.
--   
--   Here are some examples of how a <a>SizeRequestModeHeightForWidth</a>
--   widget generally deals with width-for-height requests:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   foo_widget_measure (GtkWidget      *widget,
--                       GtkOrientation  orientation,
--                       int             for_size,
--                       int            *minimum_size,
--                       int            *natural_size,
--                       int            *minimum_baseline,
--                       int            *natural_baseline)
--   {
--     if (orientation == GTK_ORIENTATION_HORIZONTAL)
--       {
--         // Calculate minimum and natural width
--       }
--     else // VERTICAL
--       {
--         if (i_am_in_height_for_width_mode)
--           {
--             int min_width, dummy;
--   
--             // First, get the minimum width of our widget
--             GTK_WIDGET_GET_CLASS (widget)-&gt;measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
--                                                     &amp;min_width, &amp;dummy, &amp;dummy, &amp;dummy);
--   
--             // Now use the minimum width to retrieve the minimum and natural height to display
--             // that width.
--             GTK_WIDGET_GET_CLASS (widget)-&gt;measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
--                                                     minimum_size, natural_size, &amp;dummy, &amp;dummy);
--           }
--         else
--           {
--             // ... some widgets do both.
--           }
--       }
--   }
--   </pre>
--   
--   Often a widget needs to get its own request during size request or
--   allocation. For example, when computing height it may need to also
--   compute width. Or when deciding how to use an allocation, the widget
--   may need to know its natural size. In these cases, the widget should
--   be careful to call its virtual methods directly, like in the code
--   example above.
--   
--   It will not work to use the wrapper function <a>widgetMeasure</a>
--   inside your own <a>Widget</a>.<tt><i>size_allocate</i></tt>()
--   implementation. These return a request adjusted by <a>SizeGroup</a>,
--   the widget's align and expand flags, as well as its CSS style.
--   
--   If a widget used the wrappers inside its virtual method
--   implementations, then the adjustments (such as widget margins) would
--   be applied twice. GTK therefore does not allow this and will warn if
--   you try to do it.
--   
--   Of course if you are getting the size request for another widget, such
--   as a child widget, you must use <a>widgetMeasure</a>; otherwise, you
--   would not properly consider widget margins, <a>SizeGroup</a>, and so
--   forth.
--   
--   GTK also supports baseline vertical alignment of widgets. This means
--   that widgets are positioned such that the typographical baseline of
--   widgets in the same row are aligned. This happens if a widget supports
--   baselines, has a vertical alignment using baselines, and is inside a
--   widget that supports baselines and has a natural “row” that it aligns
--   to the baseline, or a baseline assigned to it by the grandparent.
--   
--   Baseline alignment support for a widget is also done by the
--   <a>Widget</a>.<tt><i>measure</i></tt>() virtual function. It allows
--   you to report both a minimum and natural size.
--   
--   If a widget ends up baseline aligned it will be allocated all the
--   space in the parent as if it was <a>AlignFill</a>, but the selected
--   baseline can be found via <a>widgetGetBaseline</a>. If the baseline
--   has a value other than -1 you need to align the widget such that the
--   baseline appears at the position.
--   
--   <h3>GtkWidget as GtkBuildable</h3>
--   
--   The <tt>GtkWidget</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports various custom elements to specify additional
--   aspects of widgets that are not directly expressed as properties.
--   
--   If the widget uses a <a>LayoutManager</a>, <tt>GtkWidget</tt> supports
--   a custom <tt>&lt;layout&gt;</tt> element, used to define layout
--   properties:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkGrid" id="my_grid"&gt;
--     &lt;child&gt;
--       &lt;object class="GtkLabel" id="label1"&gt;
--         &lt;property name="label"&gt;Description&lt;/property&gt;
--         &lt;layout&gt;
--           &lt;property name="column"&gt;0&lt;/property&gt;
--           &lt;property name="row"&gt;0&lt;/property&gt;
--           &lt;property name="row-span"&gt;1&lt;/property&gt;
--           &lt;property name="column-span"&gt;1&lt;/property&gt;
--         &lt;/layout&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;child&gt;
--       &lt;object class="GtkEntry" id="description_entry"&gt;
--         &lt;layout&gt;
--           &lt;property name="column"&gt;1&lt;/property&gt;
--           &lt;property name="row"&gt;0&lt;/property&gt;
--           &lt;property name="row-span"&gt;1&lt;/property&gt;
--           &lt;property name="column-span"&gt;1&lt;/property&gt;
--         &lt;/layout&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <tt>GtkWidget</tt> allows style information such as style classes to
--   be associated with widgets, using the custom <tt>&lt;style&gt;</tt>
--   element:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkButton" id="button1"&gt;
--     &lt;style&gt;
--       &lt;class name="my-special-button-class"/&gt;
--       &lt;class name="dark-button"/&gt;
--     &lt;/style&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <tt>GtkWidget</tt> allows defining accessibility information, such as
--   properties, relations, and states, using the custom
--   <tt>&lt;accessibility&gt;</tt> element:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkButton" id="button1"&gt;
--     &lt;accessibility&gt;
--       &lt;property name="label"&gt;Download&lt;/property&gt;
--       &lt;relation name="labelled-by"&gt;label1&lt;/relation&gt;
--     &lt;/accessibility&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h3>Building composite widgets from template XML</h3>
--   
--   <tt>GtkWidget </tt>exposes some facilities to automate the procedure
--   of creating composite widgets using "templates".
--   
--   To create composite widgets with <tt>GtkBuilder</tt> XML, one must
--   associate the interface description with the widget class at class
--   initialization time using <a>widgetClassSetTemplate</a>.
--   
--   The interface description semantics expected in composite template
--   descriptions is slightly different from regular <a>Builder</a> XML.
--   
--   Unlike regular interface descriptions, <a>widgetClassSetTemplate</a>
--   will expect a <tt>&lt;template&gt;</tt> tag as a direct child of the
--   toplevel <tt>&lt;interface&gt;</tt> tag. The <tt>&lt;template&gt;</tt>
--   tag must specify the “class” attribute which must be the type name of
--   the widget. Optionally, the “parent” attribute may be specified to
--   specify the direct parent type of the widget type; this is ignored by
--   <tt>GtkBuilder</tt> but can be used by UI design tools to introspect
--   what kind of properties and internal children exist for a given type
--   when the actual type does not exist.
--   
--   The XML which is contained inside the <tt>&lt;template&gt;</tt> tag
--   behaves as if it were added to the <tt>&lt;object&gt;</tt> tag
--   defining the widget itself. You may set properties on a widget by
--   inserting <tt>&lt;property&gt;</tt> tags into the
--   <tt>&lt;template&gt;</tt> tag, and also add <tt>&lt;child&gt;</tt>
--   tags to add children and extend a widget in the normal way you would
--   with <tt>&lt;object&gt;</tt> tags.
--   
--   Additionally, <tt>&lt;object&gt;</tt> tags can also be added before
--   and after the initial <tt>&lt;template&gt;</tt> tag in the normal way,
--   allowing one to define auxiliary objects which might be referenced by
--   other widgets declared as children of the <tt>&lt;template&gt;</tt>
--   tag.
--   
--   Since, unlike the <tt>&lt;object&gt;</tt> tag, the
--   <tt>&lt;template&gt;</tt> tag does not contain an “id” attribute, if
--   you need to refer to the instance of the object itself that the
--   template will create, simply refer to the template class name in an
--   applicable element content.
--   
--   Here is an example of a template definition, which includes an example
--   of this in the <tt>&lt;signal&gt;</tt> tag:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;interface&gt;
--     &lt;template class="FooWidget" parent="GtkBox"&gt;
--       &lt;property name="orientation"&gt;horizontal&lt;/property&gt;
--       &lt;property name="spacing"&gt;4&lt;/property&gt;
--       &lt;child&gt;
--         &lt;object class="GtkButton" id="hello_button"&gt;
--           &lt;property name="label"&gt;Hello World&lt;/property&gt;
--           &lt;signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/&gt;
--         &lt;/object&gt;
--       &lt;/child&gt;
--       &lt;child&gt;
--         &lt;object class="GtkButton" id="goodbye_button"&gt;
--           &lt;property name="label"&gt;Goodbye World&lt;/property&gt;
--         &lt;/object&gt;
--       &lt;/child&gt;
--     &lt;/template&gt;
--   &lt;/interface&gt;
--   </pre>
--   
--   Typically, you'll place the template fragment into a file that is
--   bundled with your project, using <tt>GResource</tt>. In order to load
--   the template, you need to call
--   <a>widgetClassSetTemplateFromResource</a> from the class
--   initialization of your <tt>GtkWidget</tt> type:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   foo_widget_class_init (FooWidgetClass *klass)
--   {
--     // ...
--   
--     gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
--                                                  "/com/example/ui/foowidget.ui");
--   }
--   </pre>
--   
--   You will also need to call <a>widgetInitTemplate</a> from the instance
--   initialization function:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   foo_widget_init (FooWidget *self)
--   {
--     gtk_widget_init_template (GTK_WIDGET (self));
--   
--     // Initialize the rest of the widget...
--   }
--   </pre>
--   
--   as well as calling <a>widgetDisposeTemplate</a> from the dispose
--   function:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   foo_widget_dispose (GObject *gobject)
--   {
--     FooWidget *self = FOO_WIDGET (gobject);
--   
--     // Dispose objects for which you have a reference...
--   
--     // Clear the template children for this widget type
--     gtk_widget_dispose_template (GTK_WIDGET (self), FOO_TYPE_WIDGET);
--   
--     G_OBJECT_CLASS (foo_widget_parent_class)-&gt;dispose (gobject);
--   }
--   </pre>
--   
--   You can access widgets defined in the template using the
--   <a>widgetGetTemplateChild</a> function, but you will typically declare
--   a pointer in the instance private data structure of your type using
--   the same name as the widget in the template definition, and call
--   <a>widgetClassBindTemplateChildFull</a> (or one of its wrapper macros
--   <tt><i>Gtk.widget_class_bind_template_child</i></tt> and
--   <tt><i>Gtk.widget_class_bind_template_child_private</i></tt>) with
--   that name, e.g.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   typedef struct {
--     GtkWidget *hello_button;
--     GtkWidget *goodbye_button;
--   } FooWidgetPrivate;
--   
--   G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
--   
--   static void
--   foo_widget_dispose (GObject *gobject)
--   {
--     gtk_widget_dispose_template (GTK_WIDGET (gobject), FOO_TYPE_WIDGET);
--   
--     G_OBJECT_CLASS (foo_widget_parent_class)-&gt;dispose (gobject);
--   }
--   
--   static void
--   foo_widget_class_init (FooWidgetClass *klass)
--   {
--     // ...
--     G_OBJECT_CLASS (klass)-&gt;dispose = foo_widget_dispose;
--   
--     gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
--                                                  "/com/example/ui/foowidget.ui");
--     gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
--                                                   FooWidget, hello_button);
--     gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
--                                                   FooWidget, goodbye_button);
--   }
--   
--   static void
--   foo_widget_init (FooWidget *widget)
--   {
--     gtk_widget_init_template (GTK_WIDGET (widget));
--   }
--   </pre>
--   
--   You can also use <a>widgetClassBindTemplateCallbackFull</a> (or is
--   wrapper macro <tt><i>Gtk.widget_class_bind_template_callback</i></tt>)
--   to connect a signal callback defined in the template with a function
--   visible in the scope of the class, e.g.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // the signal handler has the instance and user data swapped
--   // because of the swapped="yes" attribute in the template XML
--   static void
--   hello_button_clicked (FooWidget *self,
--                         GtkButton *button)
--   {
--     g_print ("Hello, world!\n");
--   }
--   
--   static void
--   foo_widget_class_init (FooWidgetClass *klass)
--   {
--     // ...
--     gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
--                                                  "/com/example/ui/foowidget.ui");
--     gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
--   }
--   </pre>
module GI.Gtk.Objects.Widget

-- | Memory-managed wrapper type.
newtype Widget
Widget :: ManagedPtr Widget -> Widget

-- | Type class for types which can be safely cast to <a>Widget</a>, for
--   instance with <a>toWidget</a>.
class (GObject o, IsDescendantOf Widget o) => IsWidget o

-- | Cast to <a>Widget</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toWidget :: (MonadIO m, IsWidget o) => o -> m Widget

-- | Enables or disables an action installed with
--   <a>widgetClassInstallAction</a>.
widgetActionSetEnabled :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Bool -> m ()

-- | Activates the widget.
--   
--   The activation will emit the signal set using
--   <a>widgetClassSetActivateSignal</a> during class initialization.
--   
--   Activation is what happens when you press &lt;kbd&gt;Enter&lt;/kbd&gt;
--   on a widget.
--   
--   If you wish to handle the activation keybinding yourself, it is
--   recommended to use <a>widgetClassAddShortcut</a> with an action
--   created with <a>signalActionNew</a>.
--   
--   If <i><tt>widget</tt></i> is not activatable, the function returns
--   false.
widgetActivate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Activates an action for the widget.
--   
--   The action is looked up in the action groups associated with
--   <i><tt>widget</tt></i> and its ancestors.
--   
--   If the action is in an action group added with
--   <a>widgetInsertActionGroup</a>, the <i><tt>name</tt></i> is expected
--   to be prefixed with the prefix that was used when the group was
--   inserted.
--   
--   The arguments must match the actions expected parameter type, as
--   returned by <a>actionGetParameterType</a>.
widgetActivateAction :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> Maybe GVariant -> m Bool

-- | Activates the <tt>default.activate</tt> action for the widget.
--   
--   The action is looked up in the same was as for
--   <a>widgetActivateAction</a>.
widgetActivateDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Adds an event controller to the widget.
--   
--   The event controllers of a widget handle the events that are
--   propagated to the widget.
--   
--   You will usually want to call this function right after creating any
--   kind of <a>EventController</a>.
widgetAddController :: (HasCallStack, MonadIO m, IsWidget a, IsEventController b) => a -> b -> m ()

-- | Adds a style class to the widget.
--   
--   After calling this function, the widget’s style will match for
--   <i><tt>cssClass</tt></i>, according to CSS matching rules.
--   
--   Use <a>widgetRemoveCssClass</a> to remove the style again.
widgetAddCssClass :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Adds a widget to the list of mnemonic labels for this widget.
--   
--   See <a>widgetListMnemonicLabels</a>.
--   
--   Note that 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.
widgetAddMnemonicLabel :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Queues an animation frame update and adds a callback to be called
--   before each frame.
--   
--   Until the tick callback is removed, it will be called frequently
--   (usually at the frame rate of the output device or as quickly as the
--   application can be repainted, whichever is slower). For this reason,
--   is most suitable for handling graphics that change every frame or
--   every few frames.
--   
--   The tick callback does not automatically imply a relayout or repaint.
--   If you want a repaint or relayout, and aren’t changing widget
--   properties that would trigger that (for example, changing the text of
--   a label), then you will have to call <a>widgetQueueResize</a> or
--   <a>widgetQueueDraw</a> yourself.
--   
--   <a>frameClockGetFrameTime</a> should generally be used for timing
--   continuous animations and
--   <a>frameTimingsGetPredictedPresentationTime</a> should be used if you
--   are trying to display isolated frames at particular times.
--   
--   This is a more convenient alternative to connecting directly to the
--   <a>FrameClock::update</a> signal of the frame clock, since you don't
--   have to worry about when a frame clock is assigned to a widget.
--   
--   To remove a tick callback, pass the ID that is returned by this
--   function to <a>widgetRemoveTickCallback</a>.
widgetAddTickCallback :: (HasCallStack, MonadIO m, IsWidget a) => a -> TickCallback -> m Word32

-- | Assigns size, position, (optionally) a baseline and transform to a
--   child widget.
--   
--   In this function, the allocation and baseline may be adjusted. The
--   given allocation will be forced to be bigger than the widget's minimum
--   size, as well as at least 0×0 in size.
--   
--   This function is only used by widget implementations.
--   
--   For a version that does not take a transform, see
--   <a>widgetSizeAllocate</a>.
widgetAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> Int32 -> Maybe Transform -> m ()

-- | Called by widgets as the user moves around the window using keyboard
--   shortcuts.
--   
--   The <i><tt>direction</tt></i> argument indicates what kind of motion
--   is taking place (up, down, left, right, tab forward, tab backward).
--   
--   This function calls the <a>Widget</a>.<tt><i>focus</i></tt>() virtual
--   function; widgets can override the virtual function in order to
--   implement appropriate focus behavior.
--   
--   The default <tt>focus()</tt> virtual function for a widget should
--   return true if moving in <i><tt>direction</tt></i> left the focus on a
--   focusable location inside that widget, and false if moving in
--   <i><tt>direction</tt></i> moved the focus outside the widget. When
--   returning true, widgets normally call <a>widgetGrabFocus</a> to place
--   the focus accordingly; when returning false, they don’t modify the
--   current focus location.
--   
--   This function is used by custom widget implementations; if you're
--   writing an app, you’d use <a>widgetGrabFocus</a> to move the focus to
--   a particular widget.
widgetChildFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> DirectionType -> m Bool

-- | Computes the bounds for <i><tt>widget</tt></i> in the coordinate space
--   of <i><tt>target</tt></i>.
--   
--   The bounds of widget are (the bounding box of) the region that it is
--   expected to draw in. See the <a>coordinate system</a> overview to
--   learn more.
--   
--   If the operation is successful, true is returned. If
--   <i><tt>widget</tt></i> has no bounds or the bounds cannot be expressed
--   in <i><tt>target</tt></i>'s coordinate space (for example if both
--   widgets are in different windows), false is returned and
--   <i><tt>bounds</tt></i> is set to the zero rectangle.
--   
--   It is valid for <i><tt>widget</tt></i> and <i><tt>target</tt></i> to
--   be the same widget.
widgetComputeBounds :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m (Bool, Rect)

-- | Computes whether a parent widget should give this widget extra space
--   when possible.
--   
--   Widgets with children should check this, rather than looking at
--   <a>widgetGetHexpand</a> or <a>widgetGetVexpand</a>.
--   
--   This function already checks whether the widget is visible, so
--   visibility does not need to be checked separately. Non-visible widgets
--   are not expanded.
--   
--   The computed expand value uses either the expand setting explicitly
--   set on the widget itself, or, if none has been explicitly set, the
--   widget may expand if some of its children do.
widgetComputeExpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> Orientation -> m Bool

-- | Translates the given <i><tt>point</tt></i> in <i><tt>widget</tt></i>'s
--   coordinates to coordinates in <i><tt>target</tt></i>’s coordinate
--   system.
--   
--   In order to perform this operation, both widgets must share a a common
--   ancestor. If that is not the case, <i><tt>outPoint</tt></i> is set to
--   (0, 0) and false is returned.
widgetComputePoint :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> Point -> m (Bool, Point)

-- | Computes a matrix suitable to describe a transformation from
--   <i><tt>widget</tt></i>'s coordinate system into
--   <i><tt>target</tt></i>'s coordinate system.
--   
--   The transform can not be computed in certain cases, for example when
--   <i><tt>widget</tt></i> and <i><tt>target</tt></i> do not share a
--   common ancestor. In that case <i><tt>outTransform</tt></i> gets set to
--   the identity matrix.
--   
--   To learn more about widget coordinate systems, see the coordinate
--   system <a>overview</a>.
widgetComputeTransform :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m (Bool, Matrix)

-- | Tests if a given point is contained in the widget.
--   
--   The coordinates for (x, y) must be in widget coordinates, so (0, 0) is
--   assumed to be the top left of <i><tt>widget</tt></i>'s content area.
widgetContains :: (HasCallStack, MonadIO m, IsWidget a) => a -> Double -> Double -> m Bool

-- | Creates a new <tt>PangoContext</tt> that is configured for the widget.
--   
--   The <tt>PangoContext</tt> will have the appropriate font map, font
--   options, font description, and base direction set.
--   
--   See also <a>widgetGetPangoContext</a>.
widgetCreatePangoContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Context

-- | Creates a new <tt>PangoLayout</tt> that is configured for the widget.
--   
--   The <tt>PangoLayout</tt> will have the appropriate font map, font
--   description, and base direction set.
--   
--   If you keep a <tt>PangoLayout</tt> created in this way around, you
--   need to re-create it when the widgets <tt>PangoContext</tt> is
--   replaced. This can be tracked by listening to changes of the
--   <a>Widget:root</a> property on the widget.
widgetCreatePangoLayout :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m Layout

-- | Clears the template children for the widget.
--   
--   This function is the opposite of <a>widgetInitTemplate</a>, and it is
--   used to clear all the template children from a widget instance. If you
--   bound a template child to a field in the instance structure, or in the
--   instance private data structure, the field will be set to
--   <tt>NULL</tt> after this function returns.
--   
--   You should call this function inside the
--   <tt>GObjectClass.dispose()</tt> implementation of any widget that
--   called <a>widgetInitTemplate</a>. Typically, you will want to call
--   this function last, right before chaining up to the parent type's
--   dispose implementation, e.g.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   some_widget_dispose (GObject *gobject)
--   {
--     SomeWidget *self = SOME_WIDGET (gobject);
--   
--     // Clear the template data for SomeWidget
--     gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
--   
--     G_OBJECT_CLASS (some_widget_parent_class)-&gt;dispose (gobject);
--   }
--   </pre>
--   
--   <i>Since: 4.8</i>
widgetDisposeTemplate :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> m ()

-- | Checks to see if a drag movement has passed the GTK drag threshold.
widgetDragCheckThreshold :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> m Bool

-- | Notifies the user about an input-related error on the widget.
--   
--   If the <a>Settings:gtkErrorBell</a> setting is true, it calls
--   <a>surfaceBeep</a>, otherwise it does nothing.
--   
--   Note that the effect of <a>surfaceBeep</a> can be configured in many
--   ways, depending on the windowing backend and the desktop environment
--   or window manager that is used.
widgetErrorBell :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Returns the baseline that has currently been allocated to the widget.
--   
--   This function is intended to be used when implementing handlers for
--   the <tt>GtkWidget</tt>Class.<tt><i>snapshot()</i></tt> function, and
--   when allocating child widgets in
--   <tt>GtkWidget</tt>Class.<tt><i>size_allocate()</i></tt>.

-- | <i>Deprecated: (Since version 4.12)Use <a>widgetGetBaseline</a>
--   instead</i>
widgetGetAllocatedBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the height that has currently been allocated to the widget.
--   
--   To learn more about widget sizes, see the coordinate system
--   <a>overview</a>.

-- | <i>Deprecated: (Since version 4.12)Use <a>widgetGetHeight</a>
--   instead</i>
widgetGetAllocatedHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the width that has currently been allocated to the widget.
--   
--   To learn more about widget sizes, see the coordinate system
--   <a>overview</a>.

-- | <i>Deprecated: (Since version 4.12)Use <a>widgetGetWidth</a>
--   instead</i>
widgetGetAllocatedWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Retrieves the widget’s allocation.
--   
--   Note, when implementing a layout widget: a widget’s allocation will be
--   its “adjusted” allocation, that is, the widget’s parent typically
--   calls <a>widgetSizeAllocate</a> with an allocation, and that
--   allocation is then adjusted (to handle margin and alignment for
--   example) before assignment to the widget. <a>widgetGetAllocation</a>
--   returns the adjusted allocation that was actually assigned to the
--   widget. The adjusted allocation is guaranteed to be completely
--   contained within the <a>widgetSizeAllocate</a> allocation, however.
--   
--   So a layout widget is guaranteed that its children stay inside the
--   assigned bounds, but not that they have exactly the bounds the widget
--   assigned.

-- | <i>Deprecated: (Since version 4.12)Use
--   <a>widgetComputeBounds</a>,<a>widgetGetWidth</a> or
--   <a>widgetGetHeight</a> instead.</i>
widgetGetAllocation :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Rectangle

-- | Gets the first ancestor of the widget with type
--   <i><tt>widgetType</tt></i>.
--   
--   For example, <tt>gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)</tt>
--   gets the first <tt>GtkBox</tt> that’s an ancestor of
--   <i><tt>widget</tt></i>. No reference will be added to the returned
--   widget; it should not be unreferenced.
--   
--   Note that unlike <a>widgetIsAncestor</a>, this function considers
--   <i><tt>widget</tt></i> to be an ancestor of itself.
widgetGetAncestor :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> m (Maybe Widget)

-- | Returns the baseline that has currently been allocated to the widget.
--   
--   This function is intended to be used when implementing handlers for
--   the <tt>GtkWidgetClass.snapshot()</tt> function, and when allocating
--   child widgets in <tt>GtkWidgetClass.size_allocate()</tt>.
--   
--   <i>Since: 4.12</i>
widgetGetBaseline :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Determines whether the input focus can enter the widget or any of its
--   children.
--   
--   See <a>widgetSetCanFocus</a>.
widgetGetCanFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Queries whether the widget can be the target of pointer events.
widgetGetCanTarget :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the value set with <a>widgetSetChildVisible</a>.
--   
--   If you feel a need to use this function, your code probably needs
--   reorganization.
--   
--   This function is only useful for widget implementations and should
--   never be called by an application.
widgetGetChildVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the clipboard object for the widget.
--   
--   This is a utility function to get the clipboard object for the display
--   that <i><tt>widget</tt></i> is using.
--   
--   Note that this function always works, even when <i><tt>widget</tt></i>
--   is not realized yet.
widgetGetClipboard :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Clipboard

-- | Gets the current foreground color for the widget’s style.
--   
--   This function should only be used in snapshot implementations that
--   need to do custom drawing with the foreground color.
--   
--   <i>Since: 4.10</i>
widgetGetColor :: (HasCallStack, MonadIO m, IsWidget a) => a -> m RGBA

-- | Returns the list of style classes applied to the widget.
widgetGetCssClasses :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Text]

-- | Returns the CSS name of the widget.
widgetGetCssName :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Text

-- | Gets the cursor set on the widget.
--   
--   See <a>widgetSetCursor</a> for details.
widgetGetCursor :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Cursor)

-- | Obtains the default reading direction.
--   
--   See <a>widgetSetDefaultDirection</a>.
widgetGetDefaultDirection :: (HasCallStack, MonadIO m) => m TextDirection

-- | Gets the reading direction for the widget.
--   
--   See <a>widgetSetDirection</a>.
widgetGetDirection :: (HasCallStack, MonadIO m, IsWidget a) => a -> m TextDirection

-- | Get the display for the window that the widget belongs to.
--   
--   This function can only be called after the widget has been added to a
--   widget hierarchy with a <tt>GtkRoot</tt> at the top.
--   
--   In general, you should only create display-specific resources when a
--   widget has been realized, and you should free those resources when the
--   widget is unrealized.
widgetGetDisplay :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Display

-- | Returns the widget’s first child.
--   
--   This function is primarily meant for widget implementations.
widgetGetFirstChild :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Returns the focus child of the widget.
widgetGetFocusChild :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Returns whether the widget should grab focus when it is clicked with
--   the mouse.
--   
--   See <a>widgetSetFocusOnClick</a>.
widgetGetFocusOnClick :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether the widget can own the input focus.
--   
--   See <a>widgetSetFocusable</a>.
widgetGetFocusable :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the font map of the widget.
--   
--   See <a>widgetSetFontMap</a>.
widgetGetFontMap :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FontMap)

-- | Returns the <tt>cairo_font_options_t</tt> of the widget.
--   
--   Seee <a>widgetSetFontOptions</a>.

-- | <i>Deprecated: (Since version 4.16)</i>
widgetGetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FontOptions)

-- | Obtains the frame clock for a widget.
--   
--   The frame clock is a global “ticker” that can be used to drive
--   animations and repaints. The most common reason to get the frame clock
--   is to call <a>frameClockGetFrameTime</a>, in order to get a time to
--   use for animating. For example you might record the start of the
--   animation with an initial value from <a>frameClockGetFrameTime</a>,
--   and then update the animation by calling <a>frameClockGetFrameTime</a>
--   again during each repaint.
--   
--   <a>frameClockRequestPhase</a> will result in a new frame on the clock,
--   but won’t necessarily repaint any widgets. To repaint a widget, you
--   have to use <a>widgetQueueDraw</a> which invalidates the widget (thus
--   scheduling it to receive a draw on the next frame).
--   <a>widgetQueueDraw</a> will also end up requesting a frame on the
--   appropriate frame clock.
--   
--   A widget’s frame clock will not change while the widget is mapped.
--   Reparenting a widget (which implies a temporary unmap) can change the
--   widget’s frame clock.
--   
--   Unrealized widgets do not have a frame clock.
widgetGetFrameClock :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe FrameClock)

-- | Gets the horizontal alignment of the widget.
--   
--   For backwards compatibility reasons this method will never return one
--   of the baseline alignments, but instead it will convert it to
--   <a>AlignFill</a> or <a>AlignCenter</a>.
--   
--   Baselines are not supported for horizontal alignment.
widgetGetHalign :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Align

-- | Returns the current value of the <tt>has-tooltip</tt> property.
widgetGetHasTooltip :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns the content height of the widget.
--   
--   This function returns the height passed to its size-allocate
--   implementation, which is the height you should be using in
--   <a>Widget</a>.<tt><i>snapshot</i></tt>().
--   
--   For pointer events, see <a>widgetContains</a>.
--   
--   To learn more about widget sizes, see the coordinate system
--   <a>overview</a>.
widgetGetHeight :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets whether the widget would like any available extra horizontal
--   space.
--   
--   When a user resizes a window, widgets with expand set to true
--   generally receive the extra space. For example, a list or scrollable
--   area or document in your window would often be set to expand.
--   
--   Widgets with children should use <a>widgetComputeExpand</a> rather
--   than this function, to see whether any of its children, has the expand
--   flag set. If any child of a widget wants to expand, the parent may ask
--   to expand also.
--   
--   This function only looks at the widget’s own hexpand flag, rather than
--   computing whether the entire widget tree rooted at this widget wants
--   to expand.
widgetGetHexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets whether the <tt>hexpand</tt> flag has been explicitly set.
--   
--   If <a>Widget:hexpand</a> property is set, then it overrides any
--   computed expand value based on child widgets. If <tt>hexpand</tt> is
--   not set, then the expand value depends on whether any children of the
--   widget would like to expand.
--   
--   There are few reasons to use this function, but it’s here for
--   completeness and consistency.
widgetGetHexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns the widget’s last child.
--   
--   This function is primarily meant for widget implementations.
widgetGetLastChild :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Retrieves the layout manager of the widget.
--   
--   See <a>widgetSetLayoutManager</a>.
widgetGetLayoutManager :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe LayoutManager)

-- | Gets the value of the <a>Widget:limitEvents</a> property.
--   
--   <i>Since: 4.18</i>
widgetGetLimitEvents :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns whether the widget is mapped.
widgetGetMapped :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the bottom margin of the widget.
widgetGetMarginBottom :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the end margin of the widget.
widgetGetMarginEnd :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the start margin of the widget.
widgetGetMarginStart :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Gets the top margin of the widget.
widgetGetMarginTop :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Retrieves the name of a widget.
--   
--   See <a>widgetSetName</a> for the significance of widget names.
widgetGetName :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Text

-- | Returns the nearest <tt>GtkNative</tt> ancestor of the widget.
--   
--   This function will return <tt>NULL</tt> if the widget is not contained
--   inside a widget tree with a native ancestor.
--   
--   <tt>GtkNative</tt> widgets will return themselves here.
widgetGetNative :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Native)

-- | Returns the widget’s next sibling.
--   
--   This function is primarily meant for widget implementations.
widgetGetNextSibling :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Fetches the requested opacity for the widget.
--   
--   See <a>widgetSetOpacity</a>.
widgetGetOpacity :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Double

-- | Returns the widget’s overflow value.
widgetGetOverflow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Overflow

-- | Gets a <tt>PangoContext</tt> that is configured for the widget.
--   
--   The <tt>PangoContext</tt> will have the appropriate font map, font
--   description, and base direction set.
--   
--   Unlike the context returned by <a>widgetCreatePangoContext</a>, this
--   context is owned by the widget (it can be used until the screen for
--   the widget changes or the widget is removed from its toplevel), and
--   will be updated to match any changes to the widget’s attributes. This
--   can be tracked by listening to changes of the <a>Widget:root</a>
--   property on the widget.
widgetGetPangoContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Context

-- | Returns the parent widget of the widget.
widgetGetParent :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Retrieves the minimum and natural size of a widget, taking into
--   account the widget’s preference for height-for-width management.
--   
--   This is used to retrieve a suitable size by container widgets which do
--   not impose any restrictions on the child placement. It can be used to
--   deduce toplevel window and menu sizes as well as child widgets in
--   free-form containers such as <tt>GtkFixed</tt>.
--   
--   Handle with care. Note that the natural height of a height-for-width
--   widget will generally be a smaller size than the minimum height, since
--   the required height for the natural width is generally smaller than
--   the required height for the minimum width.
--   
--   Use <a>widgetMeasure</a> if you want to support baseline alignment.
widgetGetPreferredSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Requisition, Requisition)

-- | Returns the widget’s previous sibling.
--   
--   This function is primarily meant for widget implementations.
widgetGetPrevSibling :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Widget)

-- | Gets the primary clipboard of the widget.
--   
--   This is a utility function to get the primary clipboard object for the
--   display that <i><tt>widget</tt></i> is using.
--   
--   Note that this function always works, even when <i><tt>widget</tt></i>
--   is not realized yet.
widgetGetPrimaryClipboard :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Clipboard

-- | Determines whether the widget is realized.
widgetGetRealized :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether the widget is always treated as the default widget
--   within its toplevel when it has the focus, even if another widget is
--   the default.
--   
--   See <a>widgetSetReceivesDefault</a>.
widgetGetReceivesDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets whether the widget prefers a height-for-width layout or a
--   width-for-height layout.
--   
--   Single-child widgets generally propagate the preference of their
--   child, more complex widgets need to request something either in
--   context of their children or in context of their allocation
--   capabilities.
widgetGetRequestMode :: (HasCallStack, MonadIO m, IsWidget a) => a -> m SizeRequestMode

-- | Returns the <tt>GtkRoot</tt> widget of the widget.
--   
--   This function will return <tt>NULL</tt> if the widget is not contained
--   inside a widget tree with a root widget.
--   
--   <tt>GtkRoot</tt> widgets will return themselves here.
widgetGetRoot :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Root)

-- | Retrieves the internal scale factor that maps from window coordinates
--   to the actual device pixels.
--   
--   On traditional systems this is 1, on high density outputs, it can be a
--   higher value (typically 2).
--   
--   See <a>surfaceGetScaleFactor</a>.
--   
--   Note that modern systems may support *fractional* scaling, where the
--   scale factor is not an integer. On such systems, this function will
--   return the next higher integer value, but you probably want to use
--   <a>surfaceGetScale</a> to get the fractional scale value.
widgetGetScaleFactor :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Returns the widget’s sensitivity.
--   
--   This function returns the value that has been set using
--   <a>widgetSetSensitive</a>).
--   
--   The effective sensitivity of a widget is however determined by both
--   its own and its parent widget’s sensitivity. See
--   <a>widgetIsSensitive</a>.
widgetGetSensitive :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets the settings object holding the settings used for the widget.
--   
--   Note that this function can only be called when the <tt>GtkWidget</tt>
--   is attached to a toplevel, since the settings object is specific to a
--   particular display. If you want to monitor the widget for changes in
--   its settings, connect to the <tt>notify::display</tt> signal.
widgetGetSettings :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Settings

-- | Returns the content width or height of the widget.
--   
--   Which dimension is returned depends on <i><tt>orientation</tt></i>.
--   
--   This is equivalent to calling <a>widgetGetWidth</a> for
--   <a>OrientationHorizontal</a> or <a>widgetGetHeight</a> for
--   <a>OrientationVertical</a>, but can be used when writing
--   orientation-independent code, such as when implementing
--   <a>Orientable</a> widgets.
--   
--   To learn more about widget sizes, see the coordinate system
--   <a>overview</a>.
widgetGetSize :: (HasCallStack, MonadIO m, IsWidget a) => a -> Orientation -> m Int32

-- | Gets the size request that was explicitly set for the widget.
--   
--   A value of -1 stored in <i><tt>width</tt></i> or
--   <i><tt>height</tt></i> indicates that that dimension has not been set
--   explicitly and the natural requisition of the widget will be used
--   instead.
--   
--   See <a>widgetSetSizeRequest</a>.
--   
--   To get the size a widget will actually request, call
--   <a>widgetMeasure</a> instead of this function.
widgetGetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Int32, Int32)

-- | Returns the widget state as a flag set.
--   
--   It is worth mentioning that the effective
--   [flags<i><tt>gtk</tt></i>.StateFlags.insensitive] state will be
--   returned, that is, also based on parent insensitivity, even if
--   <i><tt>widget</tt></i> itself is sensitive.
--   
--   Also note that if you are looking for a way to obtain the
--   [flags<i><tt>gtk</tt></i>.StateFlags] to pass to a <a>StyleContext</a>
--   method, you should look at <a>styleContextGetState</a>.
widgetGetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [StateFlags]

-- | Returns the style context associated to the widget.
--   
--   The returned object is guaranteed to be the same for the lifetime of
--   <i><tt>widget</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Style contexts will be removed in
--   GTK 5</i>
widgetGetStyleContext :: (HasCallStack, MonadIO m, IsWidget a) => a -> m StyleContext

-- | Fetches an object build from the template XML for
--   <i><tt>widgetType</tt></i> in the widget.
--   
--   This will only report children which were previously declared with
--   <a>widgetClassBindTemplateChildFull</a> or one of its variants.
--   
--   This function is only meant to be called for code which is private to
--   the <i><tt>widgetType</tt></i> which declared the child and is meant
--   for language bindings which cannot easily make use of the GObject
--   structure offsets.
widgetGetTemplateChild :: (HasCallStack, MonadIO m, IsWidget a) => a -> GType -> Text -> m Object

-- | Gets the contents of the tooltip for the widget.
--   
--   If the tooltip has not been set using <a>widgetSetTooltipMarkup</a>,
--   this function returns <tt>NULL</tt>.
widgetGetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Text)

-- | Gets the contents of the tooltip for the widget.
--   
--   If the <i><tt>widget</tt></i>'s tooltip was set using
--   <a>widgetSetTooltipMarkup</a>, this function will return the escaped
--   text.
widgetGetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> m (Maybe Text)

-- | Gets the vertical alignment of the widget.
widgetGetValign :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Align

-- | Gets whether the widget would like any available extra vertical space.
--   
--   See <a>widgetGetHexpand</a> for more detail.
widgetGetVexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Gets whether the <tt>vexpand</tt> flag has been explicitly set.
--   
--   See <a>widgetGetHexpandSet</a> for more detail.
widgetGetVexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether the widget is visible.
--   
--   If you want to take into account whether the widget’s parent is also
--   marked as visible, use <a>widgetIsVisible</a> instead.
--   
--   This function does not check if the widget is obscured in any way.
--   
--   See <a>widgetSetVisible</a>.
widgetGetVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns the content width of the widget.
--   
--   This function returns the width passed to its size-allocate
--   implementation, which is the width you should be using in
--   <a>Widget</a>.<tt><i>snapshot</i></tt>().
--   
--   For pointer events, see <a>widgetContains</a>.
--   
--   To learn more about widget sizes, see the coordinate system
--   <a>overview</a>.
widgetGetWidth :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Int32

-- | Causes <i><tt>widget</tt></i> to have the keyboard focus for the
--   window that it belongs to.
--   
--   If <i><tt>widget</tt></i> is not focusable, or its
--   <a>Widget</a>.<tt><i>grab_focus</i></tt>() implementation cannot
--   transfer the focus to a descendant of <i><tt>widget</tt></i> that is
--   focusable, it will not take focus and false will be returned.
--   
--   Calling <a>widgetGrabFocus</a> on an already focused widget is
--   allowed, should not have an effect, and return true.
widgetGrabFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns whether a style class is currently applied to the widget.
widgetHasCssClass :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m Bool

-- | Determines whether the widget is the current default widget within its
--   toplevel.
widgetHasDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget has the global input focus.
--   
--   See <a>widgetIsFocus</a> for the difference between having the global
--   input focus, and only having the focus within a toplevel.
widgetHasFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget should show a visible indication that it has
--   the global input focus.
--   
--   This is a convenience function that takes into account whether focus
--   indication should currently be shown in the toplevel window of
--   <i><tt>widget</tt></i>. See <a>windowGetFocusVisible</a> for more
--   information about focus indication.
--   
--   To find out if the widget has the global input focus, use
--   <a>widgetHasFocus</a>.
widgetHasVisibleFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Reverses the effects of [method.Gtk.Widget.show].
--   
--   This is causing the widget to be hidden (invisible to the user).

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetSetVisible</a>
--   instead</i>
widgetHide :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Returns whether the widget is currently being destroyed.
--   
--   This information can sometimes be used to avoid doing unnecessary
--   work.
widgetInDestruction :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Creates and initializes child widgets defined in templates.
--   
--   This function must be called in the instance initializer for any class
--   which assigned itself a template using <a>widgetClassSetTemplate</a>.
--   
--   It is important to call this function in the instance initializer of a
--   widget subclass and not in <tt>GObject.constructed()</tt> or
--   <tt>GObject.constructor()</tt> for two reasons:
--   
--   <ul>
--   <li>derived widgets will assume that the composite widgets defined by
--   its parent classes have been created in their relative instance
--   initializers</li>
--   <li>when calling <tt>g_object_new()</tt> on a widget with composite
--   templates, it’s important to build the composite widgets before the
--   construct properties are set. Properties passed to
--   <tt>g_object_new()</tt> should take precedence over properties set in
--   the private template XML</li>
--   </ul>
--   
--   A good rule of thumb is to call this function as the first thing in an
--   instance initialization function.
widgetInitTemplate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Inserts an action group into the widget's actions.
--   
--   Children of <i><tt>widget</tt></i> that implement <a>Actionable</a>
--   can then be associated with actions in <i><tt>group</tt></i> by
--   setting their “action-name” to
--   <i><tt>prefix</tt></i>.<tt>action-name</tt>.
--   
--   Note that inheritance is defined for individual actions. I.e. even if
--   you insert a group with prefix <i><tt>prefix</tt></i>, actions with
--   the same prefix will still be inherited from the parent, unless the
--   group contains an action with the same name.
--   
--   If <i><tt>group</tt></i> is <tt>NULL</tt>, a previously inserted group
--   for <i><tt>name</tt></i> is removed from <i><tt>widget</tt></i>.
widgetInsertActionGroup :: (HasCallStack, MonadIO m, IsWidget a, IsActionGroup b) => a -> Text -> Maybe b -> m ()

-- | Sets the parent widget of the widget.
--   
--   In contrast to <a>widgetSetParent</a>, this function inserts
--   <i><tt>widget</tt></i> at a specific position into the list of
--   children of the <i><tt>parent</tt></i> widget.
--   
--   It will be placed after <i><tt>previousSibling</tt></i>, or at the
--   beginning if <i><tt>previousSibling</tt></i> is <tt>NULL</tt>.
--   
--   After calling this function, <tt>gtk_widget_get_prev_sibling
--   (widget)</tt> will return <i><tt>previousSibling</tt></i>.
--   
--   If <i><tt>parent</tt></i> is already set as the parent widget of
--   <i><tt>widget</tt></i>, this function can also be used to reorder
--   <i><tt>widget</tt></i> in the child widget list of
--   <i><tt>parent</tt></i>.
--   
--   This function is primarily meant for widget implementations; if you
--   are just using a widget, you *must* use its own API for adding
--   children.
widgetInsertAfter :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Sets the parent widget of the widget.
--   
--   In contrast to <a>widgetSetParent</a>, this function inserts
--   <i><tt>widget</tt></i> at a specific position into the list of
--   children of the <i><tt>parent</tt></i> widget.
--   
--   It will be placed before <i><tt>nextSibling</tt></i>, or at the end if
--   <i><tt>nextSibling</tt></i> is <tt>NULL</tt>.
--   
--   After calling this function, <tt>gtk_widget_get_next_sibling
--   (widget)</tt> will return <i><tt>nextSibling</tt></i>.
--   
--   If <i><tt>parent</tt></i> is already set as the parent widget of
--   <i><tt>widget</tt></i>, this function can also be used to reorder
--   <i><tt>widget</tt></i> in the child widget list of
--   <i><tt>parent</tt></i>.
--   
--   This function is primarily meant for widget implementations; if you
--   are just using a widget, you *must* use its own API for adding
--   children.
widgetInsertBefore :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Determines whether the widget is a descendent of
--   <i><tt>ancestor</tt></i>.
widgetIsAncestor :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m Bool

-- | Determines whether the widget can be drawn to.
--   
--   A widget can be drawn if it is mapped and visible.
widgetIsDrawable :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines if the widget is the focus widget within its toplevel.
--   
--   This does not mean that the <a>Widget:hasFocus</a> property is
--   necessarily set; <a>Widget:hasFocus</a> will only be set if the
--   toplevel widget additionally has the global input focus.
widgetIsFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Returns the widget’s effective sensitivity.
--   
--   This means it is sensitive itself and also its parent widget is
--   sensitive.
widgetIsSensitive :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Determines whether the widget and all its parents are marked as
--   visible.
--   
--   This function does not check if the widget is obscured in any way.
--   
--   See also <a>widgetGetVisible</a> and <a>widgetSetVisible</a>.
widgetIsVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Emits the <a>Widget::keynavFailed</a> signal on the widget.
--   
--   This function should be called whenever keyboard navigation within a
--   single widget hits a boundary.
--   
--   The return value of this function should be interpreted in a way
--   similar to the return value of <a>widgetChildFocus</a>. When true is
--   returned, stay in the widget, the failed keyboard navigation is ok
--   and/or there is nowhere we can/should move the focus to. When false is
--   returned, the caller should continue with keyboard navigation outside
--   the widget, e.g. by calling <a>widgetChildFocus</a> on the widget’s
--   toplevel.
--   
--   The default <a>Widget::keynavFailed</a> handler returns false for
--   [enum<i><tt>gtk</tt></i>.DirectionType.tab-forward] and
--   [enum<i><tt>gtk</tt></i>.DirectionType.tab-backward]. For the other
--   values of <a>DirectionType</a> it returns true.
--   
--   Whenever the default handler returns true, it also calls
--   <a>widgetErrorBell</a> to notify the user of the failed keyboard
--   navigation.
--   
--   A use case for providing an own implementation of
--   <tt>::keynav-failed</tt> (either by connecting to it or by overriding
--   it) would be a row of <a>Entry</a> widgets where the user should be
--   able to navigate the entire row with the cursor keys, as e.g. known
--   from user interfaces that require entering license keys.
widgetKeynavFailed :: (HasCallStack, MonadIO m, IsWidget a) => a -> DirectionType -> m Bool

-- | Returns the widgets for which this widget is the target of a mnemonic.
--   
--   Typically, these widgets will be labels. See, for example,
--   <a>labelSetMnemonicWidget</a>.
--   
--   The widgets in the list are not individually referenced. If you want
--   to iterate through the list and perform actions involving callbacks
--   that might destroy the widgets, you must call <tt>g_list_foreach
--   (result, (GFunc)g_object_ref, NULL)</tt> first, and then unref all the
--   widgets afterwards.
widgetListMnemonicLabels :: (HasCallStack, MonadIO m, IsWidget a) => a -> m [Widget]

-- | Causes a widget to be mapped if it isn’t already.
--   
--   This function is only for use in widget implementations.
widgetMap :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Measures <i><tt>widget</tt></i> in the orientation
--   <i><tt>orientation</tt></i> and for the given <i><tt>forSize</tt></i>.
--   
--   As an example, if <i><tt>orientation</tt></i> is
--   <a>OrientationHorizontal</a> and <i><tt>forSize</tt></i> is 300, this
--   functions will compute the minimum and natural width of
--   <i><tt>widget</tt></i> if it is allocated at a height of 300 pixels.
--   
--   See <a>GtkWidget’s geometry management section</a> for a more details
--   on implementing <tt>GtkWidgetClass.measure()</tt>.
widgetMeasure :: (HasCallStack, MonadIO m, IsWidget a) => a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)

-- | Emits the <a>Widget::mnemonicActivate</a> signal.
widgetMnemonicActivate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m Bool

-- | Returns a list model to track the children of the widget.
--   
--   Calling this function will enable extra internal bookkeeping to track
--   children and emit signals on the returned listmodel. It may slow down
--   operations a lot.
--   
--   Applications should try hard to avoid calling this function because of
--   the slowdowns.
widgetObserveChildren :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ListModel

-- | Returns a list model to track the event controllers of the widget.
--   
--   Calling this function will enable extra internal bookkeeping to track
--   controllers and emit signals on the returned listmodel. It may slow
--   down operations a lot.
--   
--   Applications should try hard to avoid calling this function because of
--   the slowdowns.
widgetObserveControllers :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ListModel

-- | Finds the descendant of the widget closest to a point.
--   
--   The point (x, y) must be given in widget coordinates, so (0, 0) is
--   assumed to be the top left of <i><tt>widget</tt></i>'s content area.
--   
--   Usually widgets will return <tt>NULL</tt> if the given coordinate is
--   not contained in <i><tt>widget</tt></i> checked via
--   <a>widgetContains</a>. Otherwise they will recursively try to find a
--   child that does not return <tt>NULL</tt>. Widgets are however free to
--   customize their picking algorithm.
--   
--   This function is used on the toplevel to determine the widget below
--   the mouse cursor for purposes of hover highlighting and delivering
--   events.
widgetPick :: (HasCallStack, MonadIO m, IsWidget a) => a -> Double -> Double -> [PickFlags] -> m (Maybe Widget)

-- | Flags the widget for a rerun of the
--   <a>Widget</a>.<tt><i>size_allocate</i></tt>() function.
--   
--   Use this function instead of <a>widgetQueueResize</a> when the
--   <i><tt>widget</tt></i>'s size request didn't change but it wants to
--   reposition its contents.
--   
--   An example user of this function is <a>widgetSetHalign</a>.
--   
--   This function is only for use in widget implementations.
widgetQueueAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Schedules this widget to be redrawn.
--   
--   The redraw will happen in the paint phase of the current or the next
--   frame.
--   
--   This means <i><tt>widget</tt></i>'s
--   <a>Widget</a>.<tt><i>snapshot</i></tt>() implementation will be
--   called.
widgetQueueDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Flags a widget to have its size renegotiated.
--   
--   This should be called when a widget for some reason has a new size
--   request. For example, when you change the text in a <a>Label</a>, the
--   label queues a resize to ensure there’s enough space for the new text.
--   
--   Note that you cannot call <a>widgetQueueResize</a> on a widget from
--   inside its implementation of the
--   <a>Widget</a>.<tt><i>size_allocate</i></tt>() virtual method. Calls to
--   <a>widgetQueueResize</a> from inside
--   <a>Widget</a>.<tt><i>size_allocate</i></tt>() will be silently
--   ignored.
--   
--   This function is only for use in widget implementations.
widgetQueueResize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Creates the GDK resources associated with a widget.
--   
--   Normally realization happens implicitly; if you show a widget and all
--   its parent containers, then the widget will be realized and mapped
--   automatically.
--   
--   Realizing a widget requires all the widget’s parent widgets to be
--   realized; calling this function realizes the widget’s parents in
--   addition to <i><tt>widget</tt></i> itself. If a widget is not yet
--   inside a toplevel window when you realize it, bad things will happen.
--   
--   This function is primarily used in widget implementations, and isn’t
--   very useful otherwise. Many times when you think you might need it, a
--   better approach is to connect to a signal that will be called after
--   the widget is realized automatically, such as <a>Widget::realize</a>.
widgetRealize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Removes an event controller from the widget.
--   
--   The removed event controller will not receive any more events, and
--   should not be used again.
--   
--   Widgets will remove all event controllers automatically when they are
--   destroyed, there is normally no need to call this function.
widgetRemoveController :: (HasCallStack, MonadIO m, IsWidget a, IsEventController b) => a -> b -> m ()

-- | Removes a style from the widget.
--   
--   After this, the style of <i><tt>widget</tt></i> will stop matching for
--   <i><tt>cssClass</tt></i>.
widgetRemoveCssClass :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Removes a widget from the list of mnemonic labels for this widget.
--   
--   See <a>widgetListMnemonicLabels</a>.
--   
--   The widget must have previously been added to the list with
--   <a>widgetAddMnemonicLabel</a>.
widgetRemoveMnemonicLabel :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Removes a tick callback previously registered with
--   <a>widgetAddTickCallback</a>.
widgetRemoveTickCallback :: (HasCallStack, MonadIO m, IsWidget a) => a -> Word32 -> m ()

-- | Sets whether the input focus can enter the widget or any of its
--   children.
--   
--   Applications should set <i><tt>canFocus</tt></i> to false to mark a
--   widget as for pointer/touch use only.
--   
--   Note that having <i><tt>canFocus</tt></i> be true is only one of the
--   necessary conditions for being focusable. A widget must also be
--   sensitive and focusable and not have an ancestor that is marked as not
--   can-focus in order to receive input focus.
--   
--   See <a>widgetGrabFocus</a> for actually setting the input focus on a
--   widget.
widgetSetCanFocus :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the widget can be the target of pointer events.
widgetSetCanTarget :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the widget should be mapped along with its parent.
--   
--   The child visibility can be set for widget before it is added to a
--   container with <a>widgetSetParent</a>, to avoid mapping children
--   unnecessary before immediately unmapping them. However it will be
--   reset to its default state of true when the widget is removed from a
--   container.
--   
--   Note that changing the child visibility of a widget does not queue a
--   resize on the widget. Most of the time, the size of a widget is
--   computed from all visible children, whether or not they are mapped. If
--   this is not the case, the container can queue a resize itself.
--   
--   This function is only useful for widget implementations and should
--   never be called by an application.
widgetSetChildVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Replaces the current style classes of the widget with
--   <i><tt>classes</tt></i>.
widgetSetCssClasses :: (HasCallStack, MonadIO m, IsWidget a) => a -> [Text] -> m ()

-- | Sets the cursor to be shown when the pointer hovers over the widget.
--   
--   If the <i><tt>cursor</tt></i> is <tt>NULL</tt>, <i><tt>widget</tt></i>
--   will use the cursor inherited from its parent.
widgetSetCursor :: (HasCallStack, MonadIO m, IsWidget a, IsCursor b) => a -> Maybe b -> m ()

-- | Sets the cursor to be shown when the pointer hovers over the widget.
--   
--   This is a utility function that creates a cursor via
--   <a>cursorNewFromName</a> and then sets it on <i><tt>widget</tt></i>
--   with <a>widgetSetCursor</a>. See those functions for details.
--   
--   On top of that, this function allows <i><tt>name</tt></i> to be
--   <tt>NULL</tt>, which will do the same as calling
--   <a>widgetSetCursor</a> with a <tt>NULL</tt> cursor.
widgetSetCursorFromName :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

-- | Sets the default reading direction for widgets.
--   
--   See <a>widgetSetDirection</a>.
widgetSetDefaultDirection :: (HasCallStack, MonadIO m) => TextDirection -> m ()

-- | Sets the reading direction on the widget.
--   
--   This direction controls the primary direction for widgets containing
--   text, and also the direction in which the children of a container are
--   packed. The ability to set the direction is present in order so that
--   correct localization into languages with right-to-left reading
--   directions can be done.
--   
--   Generally, applications will let the default reading direction
--   prevail, except for widgets where the children are arranged in an
--   order that is explicitly visual rather than logical (such as buttons
--   for text justification).
--   
--   If the direction is set to <a>TextDirectionNone</a>, then the value
--   set by <a>widgetSetDefaultDirection</a> will be used.
widgetSetDirection :: (HasCallStack, MonadIO m, IsWidget a) => a -> TextDirection -> m ()

-- | Set the focus child of the widget.
--   
--   This function is only suitable for widget implementations. If you want
--   a certain widget to get the input focus, call <a>widgetGrabFocus</a>
--   on it.
widgetSetFocusChild :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the widget should grab focus when it is clicked with the
--   mouse.
--   
--   Making mouse clicks not grab focus is useful in places like toolbars
--   where you don’t want the keyboard focus removed from the main area of
--   the application.
widgetSetFocusOnClick :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the widget can own the input focus.
--   
--   Widget implementations should set <i><tt>focusable</tt></i> to true in
--   their <tt><i>init()</i></tt> function if they want to receive keyboard
--   input.
--   
--   Note that having <i><tt>focusable</tt></i> be true is only one of the
--   necessary conditions for being focusable. A widget must also be
--   sensitive and can-focus and not have an ancestor that is marked as not
--   can-focus in order to receive input focus.
--   
--   See <a>widgetGrabFocus</a> for actually setting the input focus on a
--   widget.
widgetSetFocusable :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the font map to use for text rendering in the widget.
--   
--   The font map is the object that is used to look up fonts. Setting a
--   custom font map can be useful in special situations, e.g. when you
--   need to add application-specific fonts to the set of available fonts.
--   
--   When not set, the widget will inherit the font map from its parent.
widgetSetFontMap :: (HasCallStack, MonadIO m, IsWidget a, IsFontMap b) => a -> Maybe b -> m ()

-- | Sets the <tt>cairo_font_options_t</tt> used for text rendering in the
--   widget.
--   
--   When not set, the default font options for the <tt>GdkDisplay</tt>
--   will be used.

-- | <i>Deprecated: (Since version 4.16)</i>
widgetSetFontOptions :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe FontOptions -> m ()

-- | Sets the horizontal alignment of the widget.
widgetSetHalign :: (HasCallStack, MonadIO m, IsWidget a) => a -> Align -> m ()

-- | Sets the <tt>has-tooltip</tt> property on the widget.
widgetSetHasTooltip :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the widget would like any available extra horizontal
--   space.
--   
--   When a user resizes a window, widgets with expand set to true
--   generally receive the extra space. For example, a list or scrollable
--   area or document in your window would often be set to expand.
--   
--   Call this function to set the expand flag if you would like your
--   widget to become larger horizontally when the window has extra room.
--   
--   By default, widgets automatically expand if any of their children want
--   to expand. (To see if a widget will automatically expand given its
--   current children and state, call <a>widgetComputeExpand</a>. A widget
--   can decide how the expandability of children affects its own expansion
--   by overriding the <tt>compute_expand</tt> virtual method on
--   <tt>GtkWidget</tt>.).
--   
--   Setting hexpand explicitly with this function will override the
--   automatic expand behavior.
--   
--   This function forces the widget to expand or not to expand, regardless
--   of children. The override occurs because <a>widgetSetHexpand</a> sets
--   the hexpand-set property (see <a>widgetSetHexpandSet</a>) which causes
--   the widget’s hexpand value to be used, rather than looking at children
--   and widget state.
widgetSetHexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the hexpand flag will be used.
--   
--   The <a>Widget:hexpandSet</a> property will be set automatically when
--   you call <a>widgetSetHexpand</a> to set hexpand, so the most likely
--   reason to use this function would be to unset an explicit expand flag.
--   
--   If hexpand is set, then it overrides any computed expand value based
--   on child widgets. If hexpand is not set, then the expand value depends
--   on whether any children of the widget would like to expand.
--   
--   There are few reasons to use this function, but it’s here for
--   completeness and consistency.
widgetSetHexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the layout manager to use for measuring and allocating children
--   of the widget.
widgetSetLayoutManager :: (HasCallStack, MonadIO m, IsWidget a, IsLayoutManager b) => a -> Maybe b -> m ()

-- | Sets whether the widget acts like a modal dialog, with respect to
--   event delivery.
--   
--   <i>Since: 4.18</i>
widgetSetLimitEvents :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the bottom margin of the widget.
widgetSetMarginBottom :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the end margin of the widget.
widgetSetMarginEnd :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the start margin of the widget.
widgetSetMarginStart :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets the top margin of the widget.
widgetSetMarginTop :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> m ()

-- | Sets a widgets name.
--   
--   Setting a name allows you to refer to the widget from a CSS file. You
--   can apply a style to widgets with a particular name in the CSS file.
--   See the documentation for the CSS syntax (on the same page as the docs
--   for <a>StyleContext</a>.
--   
--   Note that the CSS syntax has certain special characters to delimit and
--   represent elements in a selector (period, #, &gt;, *...), so using
--   these will make your widget impossible to match by name. Any
--   combination of alphanumeric symbols, dashes and underscores will
--   suffice.
widgetSetName :: (HasCallStack, MonadIO m, IsWidget a) => a -> Text -> m ()

-- | Requests the widget to be rendered partially transparent.
--   
--   An opacity of 0 is fully transparent and an opacity of 1 is fully
--   opaque.
--   
--   Opacity works on both toplevel widgets and child widgets, although
--   there are some limitations: For toplevel widgets, applying opacity
--   depends on the capabilities of the windowing system. On X11, this has
--   any effect only on X displays with a compositing manager, see
--   <a>displayIsComposited</a>. On Windows and Wayland it will always
--   work, although setting a window’s opacity after the window has been
--   shown may cause some flicker.
--   
--   Note that the opacity is inherited through inclusion — if you set a
--   toplevel to be partially translucent, all of its content will appear
--   translucent, since it is ultimatively rendered on that toplevel. The
--   opacity value itself is not inherited by child widgets (since that
--   would make widgets deeper in the hierarchy progressively more
--   translucent). As a consequence, <a>Popover</a> instances and other
--   <a>Native</a> widgets with their own surface will use their own
--   opacity value, and thus by default appear non-translucent, even if
--   they are attached to a toplevel that is translucent.
widgetSetOpacity :: (HasCallStack, MonadIO m, IsWidget a) => a -> Double -> m ()

-- | Sets how the widget treats content that is drawn outside the it's
--   content area.
--   
--   See the definition of <a>Overflow</a> for details.
--   
--   This setting is provided for widget implementations and should not be
--   used by application code.
--   
--   The default value is <a>OverflowVisible</a>.
widgetSetOverflow :: (HasCallStack, MonadIO m, IsWidget a) => a -> Overflow -> m ()

-- | Sets the parent widget of the widget.
--   
--   This takes care of details such as updating the state and style of the
--   child to reflect its new location and resizing the parent. The
--   opposite function is <a>widgetUnparent</a>.
--   
--   This function is useful only when implementing subclasses of
--   <tt>GtkWidget</tt>.
widgetSetParent :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> m ()

-- | Sets whether the widget will be treated as the default widget within
--   its toplevel when it has the focus, even if another widget is the
--   default.
widgetSetReceivesDefault :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the sensitivity of the widget.
--   
--   A widget is sensitive if the user can interact with it. Insensitive
--   widgets are “grayed out” and the user can’t interact with them.
--   Insensitive widgets are known as “inactive”, “disabled”, or “ghosted”
--   in some other toolkits.
widgetSetSensitive :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the minimum size of the widget.
--   
--   That is, the widget’s size request will be at least
--   <i><tt>width</tt></i> by <i><tt>height</tt></i>. You can use this
--   function to force a widget to be larger than it normally would be.
--   
--   In most cases, <a>windowSetDefaultSize</a> is a better choice for
--   toplevel windows than this function; setting the default size will
--   still allow users to shrink the window. Setting the size request will
--   force them to leave the window at least as large as the size request.
--   
--   Note the inherent danger of setting any fixed size - themes,
--   translations into other languages, different fonts, and user action
--   can all change the appropriate size for a given widget. So, it is
--   basically impossible to hardcode a size that will always work.
--   
--   The size request of a widget is the smallest size a widget can accept
--   while still functioning well and drawing itself correctly. However in
--   some strange cases a widget may be allocated less than its requested
--   size, and in many cases a widget may be allocated more space than it
--   requested.
--   
--   If the size request in a given direction is -1 (unset), then the
--   “natural” size request of the widget will be used instead.
--   
--   The size request set here does not include any margin from the
--   properties <a>Widget:marginStart</a>, <a>Widget:marginEnd</a>,
--   <a>Widget:marginTop</a>, and <a>Widget:marginBottom</a>, but it does
--   include pretty much all other padding or border properties set by any
--   subclass of <tt>GtkWidget</tt>.
widgetSetSizeRequest :: (HasCallStack, MonadIO m, IsWidget a) => a -> Int32 -> Int32 -> m ()

-- | Turns on flag values in the current widget state.
--   
--   Typical widget states are insensitive, prelighted, etc.
--   
--   This function accepts the values
--   [flags<i><tt>gtk</tt></i>.StateFlags.dir-ltr] and
--   [flags<i><tt>gtk</tt></i>.StateFlags.dir-rtl] but ignores them. If you
--   want to set the widget's direction, use <a>widgetSetDirection</a>.
--   
--   This function is for use in widget implementations.
widgetSetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> Bool -> m ()

-- | Sets the contents of the tooltip for widget.
--   
--   <i><tt>markup</tt></i> must contain Pango markup.
--   
--   This function will take care of setting the <a>Widget:hasTooltip</a>
--   as a side effect, and of the default handler for the
--   <a>Widget::queryTooltip</a> signal.
--   
--   See also <a>tooltipSetMarkup</a>.
widgetSetTooltipMarkup :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

-- | Sets the contents of the tooltip for the widget.
--   
--   If <i><tt>text</tt></i> contains any markup, it will be escaped.
--   
--   This function will take care of setting <a>Widget:hasTooltip</a> as a
--   side effect, and of the default handler for the
--   <a>Widget::queryTooltip</a> signal.
--   
--   See also <a>tooltipSetText</a>.
widgetSetTooltipText :: (HasCallStack, MonadIO m, IsWidget a) => a -> Maybe Text -> m ()

-- | Sets the vertical alignment of the widget.
widgetSetValign :: (HasCallStack, MonadIO m, IsWidget a) => a -> Align -> m ()

-- | Sets whether the widget would like any available extra vertical space.
--   
--   See <a>widgetSetHexpand</a> for more detail.
widgetSetVexpand :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets whether the vexpand flag will be used.
--   
--   See <a>widgetSetHexpandSet</a> for more detail.
widgetSetVexpandSet :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Sets the visibility state of <i><tt>widget</tt></i>.
--   
--   Note that setting this to true doesn’t mean the widget is actually
--   viewable, see <a>widgetGetVisible</a>.
widgetSetVisible :: (HasCallStack, MonadIO m, IsWidget a) => a -> Bool -> m ()

-- | Returns whether the widget should contribute to the measuring and
--   allocation of its parent.
--   
--   This is false for invisible children, but also for children that have
--   their own surface, such as <a>Popover</a> instances.
widgetShouldLayout :: (HasCallStack, MonadIO m, IsWidget a) => a -> m Bool

-- | Flags a widget to be displayed.
--   
--   Any widget that isn’t shown will not appear on the screen.
--   
--   Remember that you have to show the containers containing a widget, in
--   addition to the widget itself, before it will appear onscreen.
--   
--   When a toplevel widget is shown, it is immediately realized and
--   mapped; other shown widgets are realized and mapped when their
--   toplevel widget is realized and mapped.

-- | <i>Deprecated: (Since version 4.10)Use <a>widgetSetVisible</a>
--   instead</i>
widgetShow :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Allocates widget with a transformation that translates the origin to
--   the position in <i><tt>allocation</tt></i>.
--   
--   This is a simple form of <a>widgetAllocate</a>.
widgetSizeAllocate :: (HasCallStack, MonadIO m, IsWidget a) => a -> Rectangle -> Int32 -> m ()

-- | Snapshots a child of the widget.
--   
--   When a widget receives a call to the snapshot function, it must send
--   synthetic <a>Widget</a>.<tt><i>snapshot</i></tt>() calls to all
--   children. This function provides a convenient way of doing this. A
--   widget, when it receives a call to its
--   <a>Widget</a>.<tt><i>snapshot</i></tt>() function, calls
--   <a>widgetSnapshotChild</a> once for each child, passing in the
--   <i><tt>snapshot</tt></i> the widget received.
--   
--   This function takes care of translating the origin of
--   <i><tt>snapshot</tt></i>, and deciding whether the child needs to be
--   snapshot.
--   
--   It does nothing for children that implement <tt>GtkNative</tt>.
widgetSnapshotChild :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b, IsSnapshot c) => a -> b -> c -> m ()

-- | Translates coordinates relative to <i><tt>srcWidget</tt></i>’s
--   allocation to coordinates relative to <i><tt>destWidget</tt></i>’s
--   allocations.
--   
--   In order to perform this operation, both widget must share a common
--   ancestor. If that is not the case, <i><tt>destX</tt></i> and
--   <i><tt>destY</tt></i> are set to 0 and false is returned.

-- | <i>Deprecated: (Since version 4.12)Use <a>widgetComputePoint</a>
--   instead</i>
widgetTranslateCoordinates :: (HasCallStack, MonadIO m, IsWidget a, IsWidget b) => a -> b -> Double -> Double -> m (Bool, Double, Double)

-- | Triggers a tooltip query on the display of the widget.
widgetTriggerTooltipQuery :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Causes a widget to be unmapped if it’s currently mapped.
--   
--   This function is only for use in widget implementations.
widgetUnmap :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Removes <i><tt>widget</tt></i> from its parent.
--   
--   This function is only for use in widget implementations, typically in
--   dispose.
widgetUnparent :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Causes a widget to be unrealized.
--   
--   This frees all GDK resources associated with the widget.
--   
--   This function is only useful in widget implementations.
widgetUnrealize :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Turns off flag values for the current widget state.
--   
--   See <a>widgetSetStateFlags</a>.
--   
--   This function is for use in widget implementations.
widgetUnsetStateFlags :: (HasCallStack, MonadIO m, IsWidget a) => a -> [StateFlags] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-focus</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetCanFocus :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #canFocus
--   </pre>
getWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>can-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #canFocus <a>:=</a> value ]
--   </pre>
setWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-target</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetCanTarget :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #canTarget
--   </pre>
getWidgetCanTarget :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>can-target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #canTarget <a>:=</a> value ]
--   </pre>
setWidgetCanTarget :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>css-classes</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetCssClasses :: (IsWidget o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>css-classes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #cssClasses
--   </pre>
getWidgetCssClasses :: (MonadIO m, IsWidget o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>css-classes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #cssClasses <a>:=</a> value ]
--   </pre>
setWidgetCssClasses :: (MonadIO m, IsWidget o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>css-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetCssName :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>css-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #cssName
--   </pre>
getWidgetCssName :: (MonadIO m, IsWidget o) => o -> m Text

-- | Set the value of the “<tt>cursor</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #cursor
--   </pre>
clearWidgetCursor :: (MonadIO m, IsWidget o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cursor</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetCursor :: (IsWidget o, MonadIO m, IsCursor a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>cursor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #cursor
--   </pre>
getWidgetCursor :: (MonadIO m, IsWidget o) => o -> m (Maybe Cursor)

-- | Set the value of the “<tt>cursor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #cursor <a>:=</a> value ]
--   </pre>
setWidgetCursor :: (MonadIO m, IsWidget o, IsCursor a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-on-click</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetFocusOnClick :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focus-on-click</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #focusOnClick
--   </pre>
getWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>focus-on-click</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #focusOnClick <a>:=</a> value ]
--   </pre>
setWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focusable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetFocusable :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #focusable
--   </pre>
getWidgetFocusable :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #focusable <a>:=</a> value ]
--   </pre>
setWidgetFocusable :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>halign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetHalign :: (IsWidget o, MonadIO m) => Align -> m (GValueConstruct o)

-- | Get the value of the “<tt>halign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #halign
--   </pre>
getWidgetHalign :: (MonadIO m, IsWidget o) => o -> m Align

-- | Set the value of the “<tt>halign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #halign <a>:=</a> value ]
--   </pre>
setWidgetHalign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

-- | Get the value of the “<tt>has-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hasDefault
--   </pre>
getWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Get the value of the “<tt>has-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hasFocus
--   </pre>
getWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-tooltip</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetHasTooltip :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hasTooltip
--   </pre>
getWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>has-tooltip</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hasTooltip <a>:=</a> value ]
--   </pre>
setWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>height-request</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetHeightRequest :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>height-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #heightRequest
--   </pre>
getWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>height-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #heightRequest <a>:=</a> value ]
--   </pre>
setWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hexpand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetHexpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hexpand
--   </pre>
getWidgetHexpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>hexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hexpand <a>:=</a> value ]
--   </pre>
setWidgetHexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hexpand-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetHexpandSet :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #hexpandSet
--   </pre>
getWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>hexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #hexpandSet <a>:=</a> value ]
--   </pre>
setWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Set the value of the “<tt>layout-manager</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #layoutManager
--   </pre>
clearWidgetLayoutManager :: (MonadIO m, IsWidget o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>layout-manager</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetLayoutManager :: (IsWidget o, MonadIO m, IsLayoutManager a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>layout-manager</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #layoutManager
--   </pre>
getWidgetLayoutManager :: (MonadIO m, IsWidget o) => o -> m (Maybe LayoutManager)

-- | Set the value of the “<tt>layout-manager</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #layoutManager <a>:=</a> value ]
--   </pre>
setWidgetLayoutManager :: (MonadIO m, IsWidget o, IsLayoutManager a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>limit-events</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetLimitEvents :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>limit-events</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #limitEvents
--   </pre>
getWidgetLimitEvents :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>limit-events</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #limitEvents <a>:=</a> value ]
--   </pre>
setWidgetLimitEvents :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-bottom</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetMarginBottom :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-bottom</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginBottom
--   </pre>
getWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-bottom</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginBottom <a>:=</a> value ]
--   </pre>
setWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-end</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetMarginEnd :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-end</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginEnd
--   </pre>
getWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-end</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginEnd <a>:=</a> value ]
--   </pre>
setWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-start</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetMarginStart :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-start</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginStart
--   </pre>
getWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-start</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginStart <a>:=</a> value ]
--   </pre>
setWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin-top</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetMarginTop :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin-top</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #marginTop
--   </pre>
getWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>margin-top</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #marginTop <a>:=</a> value ]
--   </pre>
setWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetName :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #name
--   </pre>
getWidgetName :: (MonadIO m, IsWidget o) => o -> m Text

-- | Set the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #name <a>:=</a> value ]
--   </pre>
setWidgetName :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>opacity</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetOpacity :: (IsWidget o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>opacity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #opacity
--   </pre>
getWidgetOpacity :: (MonadIO m, IsWidget o) => o -> m Double

-- | Set the value of the “<tt>opacity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #opacity <a>:=</a> value ]
--   </pre>
setWidgetOpacity :: (MonadIO m, IsWidget o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overflow</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetOverflow :: (IsWidget o, MonadIO m) => Overflow -> m (GValueConstruct o)

-- | Get the value of the “<tt>overflow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #overflow
--   </pre>
getWidgetOverflow :: (MonadIO m, IsWidget o) => o -> m Overflow

-- | Set the value of the “<tt>overflow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #overflow <a>:=</a> value ]
--   </pre>
setWidgetOverflow :: (MonadIO m, IsWidget o) => o -> Overflow -> m ()

-- | Get the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #parent
--   </pre>
getWidgetParent :: (MonadIO m, IsWidget o) => o -> m (Maybe Widget)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>receives-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetReceivesDefault :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>receives-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #receivesDefault
--   </pre>
getWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>receives-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #receivesDefault <a>:=</a> value ]
--   </pre>
setWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Get the value of the “<tt>root</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #root
--   </pre>
getWidgetRoot :: (MonadIO m, IsWidget o) => o -> m (Maybe Root)

-- | Get the value of the “<tt>scale-factor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #scaleFactor
--   </pre>
getWidgetScaleFactor :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sensitive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructWidgetSensitive :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #sensitive
--   </pre>
getWidgetSensitive :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #sensitive <a>:=</a> value ]
--   </pre>
setWidgetSensitive :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Set the value of the “<tt>tooltip-markup</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipMarkup
--   </pre>
clearWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-markup</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructWidgetTooltipMarkup :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #tooltipMarkup
--   </pre>
getWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #tooltipMarkup <a>:=</a> value ]
--   </pre>
setWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Set the value of the “<tt>tooltip-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipText
--   </pre>
clearWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetTooltipText :: (IsWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #tooltipText
--   </pre>
getWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #tooltipText <a>:=</a> value ]
--   </pre>
setWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>valign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetValign :: (IsWidget o, MonadIO m) => Align -> m (GValueConstruct o)

-- | Get the value of the “<tt>valign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #valign
--   </pre>
getWidgetValign :: (MonadIO m, IsWidget o) => o -> m Align

-- | Set the value of the “<tt>valign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #valign <a>:=</a> value ]
--   </pre>
setWidgetValign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vexpand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetVexpand :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>vexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #vexpand
--   </pre>
getWidgetVexpand :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>vexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #vexpand <a>:=</a> value ]
--   </pre>
setWidgetVexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vexpand-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetVexpandSet :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>vexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #vexpandSet
--   </pre>
getWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>vexpand-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #vexpandSet <a>:=</a> value ]
--   </pre>
setWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructWidgetVisible :: (IsWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #visible
--   </pre>
getWidgetVisible :: (MonadIO m, IsWidget o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #visible <a>:=</a> value ]
--   </pre>
setWidgetVisible :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-request</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructWidgetWidthRequest :: (IsWidget o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widget #widthRequest
--   </pre>
getWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> m Int32

-- | Set the value of the “<tt>width-request</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widget [ #widthRequest <a>:=</a> value ]
--   </pre>
setWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

-- | Signals that all holders of a reference to the widget should release
--   the reference that they hold.
--   
--   May result in finalization of the widget if all references are
--   released.
--   
--   This signal is not suitable for saving widget state.
type WidgetDestroyCallback = IO ()

-- | Connect a signal handler for the <a>destroy</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #destroy callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDestroy :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>destroy</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #destroy callback
--   </pre>
onWidgetDestroy :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDestroyCallback) -> m SignalHandlerId

-- | Emitted when the text direction of a widget changes.
type WidgetDirectionChangedCallback = TextDirection -> IO ()

-- | Connect a signal handler for the <a>directionChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #directionChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDirectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>directionChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #directionChanged callback
--   </pre>
onWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetDirectionChangedCallback) -> m SignalHandlerId

-- | Emitted when <i><tt>widget</tt></i> is hidden.
type WidgetHideCallback = IO ()

-- | Connect a signal handler for the <a>hide</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #hide callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetHide :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHideCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>hide</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #hide callback
--   </pre>
onWidgetHide :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetHideCallback) -> m SignalHandlerId

-- | Emitted if keyboard navigation fails.
--   
--   See <a>widgetKeynavFailed</a> for details.
type WidgetKeynavFailedCallback = DirectionType -> IO Bool

-- | Connect a signal handler for the <a>keynavFailed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #keynavFailed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeynavFailedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keynavFailed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #keynavFailed callback
--   </pre>
onWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetKeynavFailedCallback) -> m SignalHandlerId

-- | Emitted when <i><tt>widget</tt></i> is going to be mapped.
--   
--   A widget is mapped when the widget is visible (which is controlled
--   with <a>Widget:visible</a>) and all its parents up to the toplevel
--   widget are also visible.
--   
--   The <tt>::map</tt> signal can be used to determine whether a widget
--   will be drawn, for instance it can resume an animation that was
--   stopped during the emission of <a>Widget::unmap</a>.
type WidgetMapCallback = IO ()

-- | Connect a signal handler for the <a>map</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #map callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>map</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #map callback
--   </pre>
onWidgetMap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMapCallback) -> m SignalHandlerId

-- | Emitted when a widget is activated via a mnemonic.
--   
--   The default handler for this signal activates <i><tt>widget</tt></i>
--   if <i><tt>groupCycling</tt></i> is false, or just makes
--   <i><tt>widget</tt></i> grab focus if <i><tt>groupCycling</tt></i> is
--   true.
type WidgetMnemonicActivateCallback = Bool -> IO Bool

-- | Connect a signal handler for the <a>mnemonicActivate</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #mnemonicActivate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMnemonicActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>mnemonicActivate</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #mnemonicActivate callback
--   </pre>
onWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMnemonicActivateCallback) -> m SignalHandlerId

-- | Emitted when the focus is moved.
--   
--   The <tt>::move-focus</tt> signal is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are &lt;kbd&gt;Tab&lt;/kbd&gt; to
--   move forward, and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; to move
--   backward.
type WidgetMoveFocusCallback = DirectionType -> IO ()

-- | Connect a signal handler for the <a>moveFocus</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #moveFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMoveFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocus</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #moveFocus callback
--   </pre>
onWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetMoveFocusCallback) -> m SignalHandlerId

-- | Emitted when the widget’s tooltip is about to be shown.
--   
--   This happens when the <a>Widget:hasTooltip</a> property is true and
--   the hover timeout has expired with the cursor hovering above
--   <i><tt>widget</tt></i>; or emitted when <i><tt>widget</tt></i> got
--   focus in keyboard mode.
--   
--   Using the given coordinates, the signal handler should determine
--   whether a tooltip should be shown for <i><tt>widget</tt></i>. If this
--   is the case true should be returned, false otherwise. Note that if
--   <i><tt>keyboardMode</tt></i> is true, the values of <i><tt>x</tt></i>
--   and <i><tt>y</tt></i> are undefined and should not be used.
--   
--   The signal handler is free to manipulate <i><tt>tooltip</tt></i> with
--   the therefore destined function calls.
type WidgetQueryTooltipCallback = Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

-- | Connect a signal handler for the <a>queryTooltip</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #queryTooltip callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetQueryTooltipCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>queryTooltip</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #queryTooltip callback
--   </pre>
onWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetQueryTooltipCallback) -> m SignalHandlerId

-- | Emitted when <i><tt>widget</tt></i> is associated with a
--   <tt>GdkSurface</tt>.
--   
--   This means that <a>widgetRealize</a> has been called or the widget has
--   been mapped (that is, it is going to be drawn).
type WidgetRealizeCallback = IO ()

-- | Connect a signal handler for the <a>realize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #realize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetRealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetRealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>realize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #realize callback
--   </pre>
onWidgetRealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetRealizeCallback) -> m SignalHandlerId

-- | Emitted when <i><tt>widget</tt></i> is shown.
type WidgetShowCallback = IO ()

-- | Connect a signal handler for the <a>show</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #show callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetShow :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>show</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #show callback
--   </pre>
onWidgetShow :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetShowCallback) -> m SignalHandlerId

-- | Emitted when the widget state changes.
--   
--   See <a>widgetGetStateFlags</a>.
type WidgetStateFlagsChangedCallback = [StateFlags] -> IO ()

-- | Connect a signal handler for the <a>stateFlagsChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> widget #stateFlagsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateFlagsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateFlagsChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> widget #stateFlagsChanged callback
--   </pre>
onWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetStateFlagsChangedCallback) -> m SignalHandlerId

-- | Emitted when <i><tt>widget</tt></i> is going to be unmapped.
--   
--   A widget is unmapped when either it or any of its parents up to the
--   toplevel widget have been set as hidden.
--   
--   As <tt>::unmap</tt> indicates that a widget will not be shown any
--   longer, it can be used to, for example, stop an animation on the
--   widget.
type WidgetUnmapCallback = IO ()

-- | Connect a signal handler for the <a>unmap</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #unmap callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetUnmap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unmap</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> widget #unmap callback
--   </pre>
onWidgetUnmap :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnmapCallback) -> m SignalHandlerId

-- | Emitted when the <tt>GdkSurface</tt> associated with
--   <i><tt>widget</tt></i> is destroyed.
--   
--   This means that <a>widgetUnrealize</a> has been called or the widget
--   has been unmapped (that is, it is going to be hidden).
type WidgetUnrealizeCallback = IO ()

-- | Connect a signal handler for the <a>unrealize</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> widget #unrealize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnrealizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unrealize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> widget #unrealize callback
--   </pre>
onWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> ((?self :: a) => WidgetUnrealizeCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Widget.Widget
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Widget.Widget
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Widget.Widget
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Widget.Widget)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Widget.Widget o) => GI.Gtk.Objects.Widget.IsWidget o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Widget.Widget
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Widget.Widget


-- | <tt>GtkVolumeButton</tt> is a <tt>GtkScaleButton</tt> subclass
--   tailored for volume control.
--   
--   &lt;picture&gt; &lt;source srcset="volumebutton-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkVolumeButton" src="volumebutton.png"&gt; &lt;/picture&gt;
module GI.Gtk.Objects.VolumeButton

-- | Memory-managed wrapper type.
newtype VolumeButton
VolumeButton :: ManagedPtr VolumeButton -> VolumeButton

-- | Type class for types which can be safely cast to <a>VolumeButton</a>,
--   for instance with <a>toVolumeButton</a>.
class (GObject o, IsDescendantOf VolumeButton o) => IsVolumeButton o

-- | Cast to <a>VolumeButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toVolumeButton :: (MonadIO m, IsVolumeButton o) => o -> m VolumeButton

-- | Creates a <tt>GtkVolumeButton</tt>.
--   
--   The button has a range between 0.0 and 1.0, with a stepping of 0.02.
--   Volume values can be obtained and modified using the functions from
--   <a>ScaleButton</a>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
volumeButtonNew :: (HasCallStack, MonadIO m) => m VolumeButton

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-symbolic</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructVolumeButtonUseSymbolic :: (IsVolumeButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-symbolic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> volumeButton #useSymbolic
--   </pre>
getVolumeButtonUseSymbolic :: (MonadIO m, IsVolumeButton o) => o -> m Bool

-- | Set the value of the “<tt>use-symbolic</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> volumeButton [ #useSymbolic <a>:=</a> value ]
--   </pre>
setVolumeButtonUseSymbolic :: (MonadIO m, IsVolumeButton o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.VolumeButton.VolumeButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.VolumeButton.VolumeButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.VolumeButton.VolumeButton
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.VolumeButton.VolumeButton)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.VolumeButton.VolumeButton o) => GI.Gtk.Objects.VolumeButton.IsVolumeButton o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.VolumeButton.VolumeButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.VolumeButton.VolumeButton


-- | Implements scrollability for widgets that don't support scrolling on
--   their own.
--   
--   Use <tt>GtkViewport</tt> to scroll child widgets such as
--   <tt>GtkGrid</tt>, <tt>GtkBox</tt>, and so on.
--   
--   The <tt>GtkViewport</tt> will start scrolling content only if
--   allocated less than the child widget’s minimum size in a given
--   orientation.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkViewport</tt> has a single CSS node with name
--   <tt>viewport</tt>.
--   
--   <h1>Accessibility</h1>
--   
--   Until GTK 4.10, <tt>GtkViewport</tt> used the
--   <a>AccessibleRoleGroup</a> role.
--   
--   Starting from GTK 4.12, <tt>GtkViewport</tt> uses the
--   <a>AccessibleRoleGeneric</a> role.
module GI.Gtk.Objects.Viewport

-- | Memory-managed wrapper type.
newtype Viewport
Viewport :: ManagedPtr Viewport -> Viewport

-- | Type class for types which can be safely cast to <a>Viewport</a>, for
--   instance with <a>toViewport</a>.
class (GObject o, IsDescendantOf Viewport o) => IsViewport o

-- | Cast to <a>Viewport</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toViewport :: (MonadIO m, IsViewport o) => o -> m Viewport

-- | Gets the child widget of <i><tt>viewport</tt></i>.
viewportGetChild :: (HasCallStack, MonadIO m, IsViewport a) => a -> m (Maybe Widget)

-- | Gets whether the viewport is scrolling to keep the focused child in
--   view.
viewportGetScrollToFocus :: (HasCallStack, MonadIO m, IsViewport a) => a -> m Bool

-- | Creates a new <tt>GtkViewport</tt>.
--   
--   The new viewport uses the given adjustments, or default adjustments if
--   none are given.
viewportNew :: (HasCallStack, MonadIO m, IsAdjustment a, IsAdjustment b) => Maybe a -> Maybe b -> m Viewport

-- | Scrolls a descendant of the viewport into view.
--   
--   The viewport and the descendant must be visible and mapped for this
--   function to work, otherwise no scrolling will be performed.
--   
--   <i>Since: 4.12</i>
viewportScrollTo :: (HasCallStack, MonadIO m, IsViewport a, IsWidget b) => a -> b -> Maybe ScrollInfo -> m ()

-- | Sets the child widget of <i><tt>viewport</tt></i>.
viewportSetChild :: (HasCallStack, MonadIO m, IsViewport a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the viewport should automatically scroll to keep the
--   focused child in view.
viewportSetScrollToFocus :: (HasCallStack, MonadIO m, IsViewport a) => a -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearViewportChild :: (MonadIO m, IsViewport o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructViewportChild :: (IsViewport o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> viewport #child
--   </pre>
getViewportChild :: (MonadIO m, IsViewport o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> viewport [ #child <a>:=</a> value ]
--   </pre>
setViewportChild :: (MonadIO m, IsViewport o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scroll-to-focus</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructViewportScrollToFocus :: (IsViewport o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>scroll-to-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> viewport #scrollToFocus
--   </pre>
getViewportScrollToFocus :: (MonadIO m, IsViewport o) => o -> m Bool

-- | Set the value of the “<tt>scroll-to-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> viewport [ #scrollToFocus <a>:=</a> value ]
--   </pre>
setViewportScrollToFocus :: (MonadIO m, IsViewport o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Viewport.Viewport
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Viewport.Viewport
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Viewport.Viewport
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Viewport.Viewport)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Viewport.Viewport o) => GI.Gtk.Objects.Viewport.IsViewport o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Viewport.Viewport
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Viewport.Viewport


-- | Shows a <tt>GtkMediaStream</tt> with media controls.
--   
--   &lt;picture&gt; &lt;source srcset="video-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkVideo" src="video.png"&gt; &lt;/picture&gt;
--   
--   The controls are available separately as <a>MediaControls</a>. If you
--   just want to display a video without controls, you can treat it like
--   any other paintable and for example put it into a <a>Picture</a>.
--   
--   <tt>GtkVideo</tt> aims to cover use cases such as previews, embedded
--   animations, etc. It supports autoplay, looping, and simple media
--   controls. It does not have support for video overlays, multichannel
--   audio, device selection, or input. If you are writing a full-fledged
--   video player, you may want to use the <a>Paintable</a> API and a media
--   framework such as Gstreamer directly.
module GI.Gtk.Objects.Video

-- | Memory-managed wrapper type.
newtype Video
Video :: ManagedPtr Video -> Video

-- | Type class for types which can be safely cast to <a>Video</a>, for
--   instance with <a>toVideo</a>.
class (GObject o, IsDescendantOf Video o) => IsVideo o

-- | Cast to <a>Video</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toVideo :: (MonadIO m, IsVideo o) => o -> m Video

-- | Returns <a>True</a> if videos have been set to loop.
videoGetAutoplay :: (HasCallStack, MonadIO m, IsVideo a) => a -> m Bool

-- | Gets the file played by <i><tt>self</tt></i> or <a>Nothing</a> if not
--   playing back a file.
videoGetFile :: (HasCallStack, MonadIO m, IsVideo a) => a -> m (Maybe File)

-- | Returns whether graphics offload is enabled.
--   
--   See <a>GraphicsOffload</a> for more information on graphics offload.
--   
--   <i>Since: 4.14</i>
videoGetGraphicsOffload :: (HasCallStack, MonadIO m, IsVideo a) => a -> m GraphicsOffloadEnabled

-- | Returns <a>True</a> if videos have been set to loop.
videoGetLoop :: (HasCallStack, MonadIO m, IsVideo a) => a -> m Bool

-- | Gets the media stream managed by <i><tt>self</tt></i> or
--   <a>Nothing</a> if none.
videoGetMediaStream :: (HasCallStack, MonadIO m, IsVideo a) => a -> m (Maybe MediaStream)

-- | Creates a new empty <tt>GtkVideo</tt>.
videoNew :: (HasCallStack, MonadIO m) => m Video

-- | Creates a <tt>GtkVideo</tt> to play back the given
--   <i><tt>file</tt></i>.
videoNewForFile :: (HasCallStack, MonadIO m, IsFile a) => Maybe a -> m Video

-- | Creates a <tt>GtkVideo</tt> to play back the given
--   <i><tt>filename</tt></i>.
--   
--   This is a utility function that calls <a>videoNewForFile</a>, See that
--   function for details.
videoNewForFilename :: (HasCallStack, MonadIO m) => Maybe [Char] -> m Video

-- | Creates a <tt>GtkVideo</tt> to play back the given
--   <i><tt>stream</tt></i>.
videoNewForMediaStream :: (HasCallStack, MonadIO m, IsMediaStream a) => Maybe a -> m Video

-- | Creates a <tt>GtkVideo</tt> to play back the resource at the given
--   <i><tt>resourcePath</tt></i>.
--   
--   This is a utility function that calls <a>videoNewForFile</a>.
videoNewForResource :: (HasCallStack, MonadIO m) => Maybe Text -> m Video

-- | Sets whether <i><tt>self</tt></i> automatically starts playback when
--   it becomes visible or when a new file gets loaded.
videoSetAutoplay :: (HasCallStack, MonadIO m, IsVideo a) => a -> Bool -> m ()

-- | Makes <i><tt>self</tt></i> play the given <i><tt>file</tt></i>.
videoSetFile :: (HasCallStack, MonadIO m, IsVideo a, IsFile b) => a -> Maybe b -> m ()

-- | Makes <i><tt>self</tt></i> play the given <i><tt>filename</tt></i>.
--   
--   This is a utility function that calls <a>videoSetFile</a>,
videoSetFilename :: (HasCallStack, MonadIO m, IsVideo a) => a -> Maybe [Char] -> m ()

-- | Sets whether to enable graphics offload.
--   
--   See <a>GraphicsOffload</a> for more information on graphics offload.
--   
--   <i>Since: 4.14</i>
videoSetGraphicsOffload :: (HasCallStack, MonadIO m, IsVideo a) => a -> GraphicsOffloadEnabled -> m ()

-- | Sets whether new files loaded by <i><tt>self</tt></i> should be set to
--   loop.
videoSetLoop :: (HasCallStack, MonadIO m, IsVideo a) => a -> Bool -> m ()

-- | Sets the media stream to be played back.
--   
--   <i><tt>self</tt></i> will take full control of managing the media
--   stream. If you want to manage a media stream yourself, consider using
--   a <a>Picture</a> for display.
--   
--   If you want to display a file, consider using <a>videoSetFile</a>
--   instead.
videoSetMediaStream :: (HasCallStack, MonadIO m, IsVideo a, IsMediaStream b) => a -> Maybe b -> m ()

-- | Makes <i><tt>self</tt></i> play the resource at the given
--   <i><tt>resourcePath</tt></i>.
--   
--   This is a utility function that calls <a>videoSetFile</a>.
videoSetResource :: (HasCallStack, MonadIO m, IsVideo a) => a -> Maybe Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>autoplay</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructVideoAutoplay :: (IsVideo o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>autoplay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> video #autoplay
--   </pre>
getVideoAutoplay :: (MonadIO m, IsVideo o) => o -> m Bool

-- | Set the value of the “<tt>autoplay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> video [ #autoplay <a>:=</a> value ]
--   </pre>
setVideoAutoplay :: (MonadIO m, IsVideo o) => o -> Bool -> m ()

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearVideoFile :: (MonadIO m, IsVideo o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructVideoFile :: (IsVideo o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> video #file
--   </pre>
getVideoFile :: (MonadIO m, IsVideo o) => o -> m (Maybe File)

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> video [ #file <a>:=</a> value ]
--   </pre>
setVideoFile :: (MonadIO m, IsVideo o, IsFile a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>graphics-offload</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructVideoGraphicsOffload :: (IsVideo o, MonadIO m) => GraphicsOffloadEnabled -> m (GValueConstruct o)

-- | Get the value of the “<tt>graphics-offload</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> video #graphicsOffload
--   </pre>
getVideoGraphicsOffload :: (MonadIO m, IsVideo o) => o -> m GraphicsOffloadEnabled

-- | Set the value of the “<tt>graphics-offload</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> video [ #graphicsOffload <a>:=</a> value ]
--   </pre>
setVideoGraphicsOffload :: (MonadIO m, IsVideo o) => o -> GraphicsOffloadEnabled -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>loop</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructVideoLoop :: (IsVideo o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>loop</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> video #loop
--   </pre>
getVideoLoop :: (MonadIO m, IsVideo o) => o -> m Bool

-- | Set the value of the “<tt>loop</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> video [ #loop <a>:=</a> value ]
--   </pre>
setVideoLoop :: (MonadIO m, IsVideo o) => o -> Bool -> m ()

-- | Set the value of the “<tt>media-stream</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #mediaStream
--   </pre>
clearVideoMediaStream :: (MonadIO m, IsVideo o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>media-stream</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructVideoMediaStream :: (IsVideo o, MonadIO m, IsMediaStream a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>media-stream</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> video #mediaStream
--   </pre>
getVideoMediaStream :: (MonadIO m, IsVideo o) => o -> m (Maybe MediaStream)

-- | Set the value of the “<tt>media-stream</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> video [ #mediaStream <a>:=</a> value ]
--   </pre>
setVideoMediaStream :: (MonadIO m, IsVideo o, IsMediaStream a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Video.Video
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Video.Video
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Video.Video
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Video.Video)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Video.Video o) => GI.Gtk.Objects.Video.IsVideo o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Video.Video
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Video.Video


-- | Asynchronous API to open a uri with an application.
--   
--   <tt>GtkUriLauncher</tt> collects the arguments that are needed to open
--   the uri.
--   
--   Depending on system configuration, user preferences and available
--   APIs, this may or may not show an app chooser dialog or launch the
--   default application right away.
--   
--   The operation is started with the <a>uriLauncherLaunch</a> function.
--   
--   To launch a file, use <a>FileLauncher</a>.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.UriLauncher

-- | Memory-managed wrapper type.
newtype UriLauncher
UriLauncher :: ManagedPtr UriLauncher -> UriLauncher

-- | Type class for types which can be safely cast to <a>UriLauncher</a>,
--   for instance with <a>toUriLauncher</a>.
class (GObject o, IsDescendantOf UriLauncher o) => IsUriLauncher o

-- | Cast to <a>UriLauncher</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toUriLauncher :: (MonadIO m, IsUriLauncher o) => o -> m UriLauncher

-- | Returns whether the launcher is likely to succeed in launching an
--   application for its uri.
--   
--   This can be used to disable controls that trigger the launcher when
--   they are known not to work.
--   
--   <i>Since: 4.20</i>
uriLauncherCanLaunch :: (HasCallStack, MonadIO m, IsUriLauncher a, IsWindow b) => a -> Maybe b -> m Bool

-- | Gets the uri that will be opened.
--   
--   <i>Since: 4.10</i>
uriLauncherGetUri :: (HasCallStack, MonadIO m, IsUriLauncher a) => a -> m (Maybe Text)

-- | Launches an application to open the uri.
--   
--   This may present an app chooser dialog to the user.
--   
--   <i>Since: 4.10</i>
uriLauncherLaunch :: (HasCallStack, MonadIO m, IsUriLauncher a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>uriLauncherLaunch</a> call and returns the result.
--   
--   <i>Since: 4.10</i>
uriLauncherLaunchFinish :: (HasCallStack, MonadIO m, IsUriLauncher a, IsAsyncResult b) => a -> b -> m ()

-- | Creates a new <tt>GtkUriLauncher</tt> object.
--   
--   <i>Since: 4.10</i>
uriLauncherNew :: (HasCallStack, MonadIO m) => Maybe Text -> m UriLauncher

-- | Sets the uri that will be opened.
--   
--   <i>Since: 4.10</i>
uriLauncherSetUri :: (HasCallStack, MonadIO m, IsUriLauncher a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>uri</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #uri
--   </pre>
clearUriLauncherUri :: (MonadIO m, IsUriLauncher o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>uri</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructUriLauncherUri :: (IsUriLauncher o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>uri</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> uriLauncher #uri
--   </pre>
getUriLauncherUri :: (MonadIO m, IsUriLauncher o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>uri</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> uriLauncher [ #uri <a>:=</a> value ]
--   </pre>
setUriLauncherUri :: (MonadIO m, IsUriLauncher o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.UriLauncher.UriLauncher
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.UriLauncher.UriLauncher
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.UriLauncher.UriLauncher
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.UriLauncher.UriLauncher)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.UriLauncher.UriLauncher o) => GI.Gtk.Objects.UriLauncher.IsUriLauncher o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.UriLauncher.UriLauncher
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.UriLauncher.UriLauncher


-- | A <tt>GtkExpression</tt> that tries to evaluate each of its
--   expressions until it succeeds.
--   
--   If all expressions fail to evaluate, the <tt>GtkTryExpression</tt>'s
--   evaluation fails as well.
--   
--   <i>Since: 4.22</i>
module GI.Gtk.Objects.TryExpression

-- | Memory-managed wrapper type.
newtype TryExpression
TryExpression :: ManagedPtr TryExpression -> TryExpression

-- | Type class for types which can be safely cast to <a>TryExpression</a>,
--   for instance with <a>toTryExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf TryExpression o) => IsTryExpression o

-- | Cast to <a>TryExpression</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTryExpression :: (MonadIO m, IsTryExpression o) => o -> m TryExpression

-- | Creates a <tt>GtkExpression</tt> with an array of expressions.
--   
--   When evaluated, the <tt>GtkTryExpression</tt> tries to evaluate each
--   of its expressions until it succeeds. If all expressions fail to
--   evaluate, the <tt>GtkTryExpression</tt>'s evaluation fails as well.
--   
--   The value type of the expressions in the array must match.
--   
--   <i>Since: 4.22</i>
tryExpressionNew :: (HasCallStack, MonadIO m) => [Expression] -> m TryExpression
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.TryExpression.TryExpression
instance GHC.Classes.Eq GI.Gtk.Objects.TryExpression.TryExpression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TryExpression.TryExpression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TryExpression.TryExpression o) => GI.Gtk.Objects.TryExpression.IsTryExpression o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TryExpression.TryExpression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TryExpression.TryExpression


-- | A visible column in a <a>TreeView</a> widget
--   
--   The <tt>GtkTreeViewColumn</tt> object represents a visible column in a
--   <tt>GtkTreeView</tt> widget. It allows to set properties of the column
--   header, and functions as a holding pen for the cell renderers which
--   determine how the data in the column is displayed.
--   
--   Please refer to the <a>tree widget conceptual overview</a> for an
--   overview of all the objects and data types related to the tree widget
--   and how they work together, and to the <a>TreeView</a> documentation
--   for specifics about the CSS node structure for treeviews and their
--   headers.
module GI.Gtk.Objects.TreeViewColumn

-- | Memory-managed wrapper type.
newtype TreeViewColumn
TreeViewColumn :: ManagedPtr TreeViewColumn -> TreeViewColumn

-- | Type class for types which can be safely cast to
--   <a>TreeViewColumn</a>, for instance with <a>toTreeViewColumn</a>.
class (GObject o, IsDescendantOf TreeViewColumn o) => IsTreeViewColumn o

-- | Cast to <a>TreeViewColumn</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeViewColumn :: (MonadIO m, IsTreeViewColumn o) => o -> m TreeViewColumn

-- | Adds an attribute mapping to the list in <i><tt>treeColumn</tt></i>.
--   
--   The <i><tt>column</tt></i> is the column of the model to get a value
--   from, and the <i><tt>attribute</tt></i> is the parameter on
--   <i><tt>cellRenderer</tt></i> to be set from the value. So for example
--   if column 2 of the model contains strings, you could have the “text”
--   attribute of a <tt>GtkCellRendererText</tt> get its values from column
--   2.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnAddAttribute :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Obtains the horizontal position and size of a cell in a column.
--   
--   If the cell is not found in the column, <i><tt>startPos</tt></i> and
--   <i><tt>width</tt></i> are not changed and <a>False</a> is returned.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnCellGetPosition :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m (Bool, Int32, Int32)

-- | Obtains the width and height needed to render the column. This is used
--   primarily by the <tt>GtkTreeView</tt>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnCellGetSize :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m (Int32, Int32, Int32, Int32)

-- | Returns <a>True</a> if any of the cells packed into the
--   <i><tt>treeColumn</tt></i> are visible. For this to be meaningful, you
--   must first initialize the cells with
--   <a>treeViewColumnCellSetCellData</a>

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnCellIsVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Sets the cell renderer based on the <i><tt>treeModel</tt></i> and
--   <i><tt>iter</tt></i>. That is, for every attribute mapping in
--   <i><tt>treeColumn</tt></i>, it will get a value from the set column on
--   the <i><tt>iter</tt></i>, and use that value to set the attribute on
--   the cell renderer. This is used primarily by the <tt>GtkTreeView</tt>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnCellSetCellData :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsTreeModel b) => a -> b -> TreeIter -> Bool -> Bool -> m ()

-- | Unsets all the mappings on all renderers on the
--   <i><tt>treeColumn</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnClear :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Clears all existing attributes previously set with
--   <tt><i>gtk_tree_view_column_set_attributes()</i></tt>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnClearAttributes :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m ()

-- | Emits the “clicked” signal on the column. This function will only work
--   if <i><tt>treeColumn</tt></i> is clickable.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnClicked :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Sets the current keyboard focus to be at <i><tt>cell</tt></i>, if the
--   column contains 2 or more editable and activatable cells.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnFocusCell :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> m ()

-- | Returns the current x alignment of <i><tt>treeColumn</tt></i>. This
--   value can range between 0.0 and 1.0.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetAlignment :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Float

-- | Returns the button used in the treeview column header

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetButton :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Widget

-- | Returns <a>True</a> if the user can click on the header for the
--   column.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetClickable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns <a>True</a> if the column expands to fill available space.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetExpand :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Gets the fixed width of the column. This may not be the actual
--   displayed width of the column; for that, use
--   <a>treeViewColumnGetWidth</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetFixedWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the maximum width in pixels of the <i><tt>treeColumn</tt></i>,
--   or -1 if no maximum width is set.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetMaxWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the minimum width in pixels of the <i><tt>treeColumn</tt></i>,
--   or -1 if no minimum width is set.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetMinWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns <a>True</a> if the <i><tt>treeColumn</tt></i> can be reordered
--   by the user.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetReorderable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns <a>True</a> if the <i><tt>treeColumn</tt></i> can be resized
--   by the end user.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetResizable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns the current type of <i><tt>treeColumn</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetSizing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m TreeViewColumnSizing

-- | Gets the logical <i><tt>sortColumnId</tt></i> that the model sorts on
--   when this column is selected for sorting.
--   
--   See <a>treeViewColumnSetSortColumnId</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Gets the value set by <a>treeViewColumnSetSortIndicator</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetSortIndicator :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Gets the value set by <a>treeViewColumnSetSortOrder</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetSortOrder :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m SortType

-- | Returns the spacing of <i><tt>treeColumn</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetSpacing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the title of the widget.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetTitle :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Text

-- | Returns the <tt>GtkTreeView</tt> wherein <i><tt>treeColumn</tt></i>
--   has been inserted. If <i><tt>column</tt></i> is currently not inserted
--   in any tree view, <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetTreeView :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m (Maybe Widget)

-- | Returns <a>True</a> if <i><tt>treeColumn</tt></i> is visible.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Bool

-- | Returns the <tt>GtkWidget</tt> in the button on the column header.
--   
--   If a custom widget has not been set then <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m (Maybe Widget)

-- | Returns the current size of <i><tt>treeColumn</tt></i> in pixels.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Returns the current X offset of <i><tt>treeColumn</tt></i> in pixels.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnGetXOffset :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m Int32

-- | Creates a new <tt>GtkTreeViewColumn</tt>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnNew :: (HasCallStack, MonadIO m) => m TreeViewColumn

-- | Creates a new <tt>GtkTreeViewColumn</tt> using <i><tt>area</tt></i> to
--   render its cells.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m TreeViewColumn

-- | Adds the <i><tt>cell</tt></i> to end of the column. If
--   <i><tt>expand</tt></i> is <a>False</a>, then the <i><tt>cell</tt></i>
--   is allocated no more space than it needs. Any unused space is divided
--   evenly between cells for which <i><tt>expand</tt></i> is <a>True</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnPackEnd :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Packs the <i><tt>cell</tt></i> into the beginning of the column. If
--   <i><tt>expand</tt></i> is <a>False</a>, then the <i><tt>cell</tt></i>
--   is allocated no more space than it needs. Any unused space is divided
--   evenly between cells for which <i><tt>expand</tt></i> is <a>True</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnPackStart :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Flags the column, and the cell renderers added to this column, to have
--   their sizes renegotiated.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnQueueResize :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> m ()

-- | Sets the alignment of the title or custom widget inside the column
--   header. The alignment determines its location inside the button -- 0.0
--   for left, 0.5 for center, 1.0 for right.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetAlignment :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Float -> m ()

-- | Sets the <tt>GtkTreeCellDataFunc</tt> to use for the column.
--   
--   This function is used instead of the standard attributes mapping for
--   setting the column value, and should set the value of
--   <i><tt>treeColumn</tt></i>'s cell renderer as appropriate.
--   <i><tt>func</tt></i> may be <a>Nothing</a> to remove an older one.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetCellDataFunc :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsCellRenderer b) => a -> b -> Maybe TreeCellDataFunc -> m ()

-- | Sets the header to be active if <i><tt>clickable</tt></i> is
--   <a>True</a>. When the header is active, then it can take keyboard
--   focus, and can be clicked.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetClickable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the column to take available extra space. This space is shared
--   equally amongst all columns that have the expand set to <a>True</a>.
--   If no column has this option set, then the last column gets all extra
--   space. By default, every column is created with this <a>False</a>.
--   
--   Along with “fixed-width”, the “expand” property changes when the
--   column is resized by the user.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetExpand :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | If <i><tt>fixedWidth</tt></i> is not -1, sets the fixed width of
--   <i><tt>treeColumn</tt></i>; otherwise unsets it. The effective value
--   of <i><tt>fixedWidth</tt></i> is clamped between the minimum and
--   maximum width of the column; however, the value stored in the
--   “fixed-width” property is not clamped. If the column sizing is
--   <a>TreeViewColumnSizingGrowOnly</a> or
--   <a>TreeViewColumnSizingAutosize</a>, setting a fixed width overrides
--   the automatically calculated width. Note that
--   <i><tt>fixedWidth</tt></i> is only a hint to GTK; the width actually
--   allocated to the column may be greater or less than requested.
--   
--   Along with “expand”, the “fixed-width” property changes when the
--   column is resized by the user.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetFixedWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Sets the maximum width of the <i><tt>treeColumn</tt></i>. If
--   <i><tt>maxWidth</tt></i> is -1, then the maximum width is unset. Note,
--   the column can actually be wider than max width if it’s the last
--   column in a view. In this case, the column expands to fill any extra
--   space.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetMaxWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Sets the minimum width of the <i><tt>treeColumn</tt></i>. If
--   <i><tt>minWidth</tt></i> is -1, then the minimum width is unset.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetMinWidth :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | If <i><tt>reorderable</tt></i> is <a>True</a>, then the column can be
--   reordered by the end user dragging the header.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetReorderable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | If <i><tt>resizable</tt></i> is <a>True</a>, then the user can
--   explicitly resize the column by grabbing the outer edge of the column
--   button.
--   
--   If resizable is <a>True</a> and sizing mode of the column is
--   <a>TreeViewColumnSizingAutosize</a>, then the sizing mode is changed
--   to <a>TreeViewColumnSizingGrowOnly</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetResizable :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the growth behavior of <i><tt>treeColumn</tt></i> to
--   <i><tt>type</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetSizing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> TreeViewColumnSizing -> m ()

-- | Sets the logical <i><tt>sortColumnId</tt></i> that this column sorts
--   on when this column is selected for sorting. Doing so makes the column
--   header clickable.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetSortColumnId :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Call this function with a <i><tt>setting</tt></i> of <a>True</a> to
--   display an arrow in the header button indicating the column is sorted.
--   Call <a>treeViewColumnSetSortOrder</a> to change the direction of the
--   arrow.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetSortIndicator :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Changes the appearance of the sort indicator.
--   
--   This does not actually sort the model. Use
--   <a>treeViewColumnSetSortColumnId</a> if you want automatic sorting
--   support. This function is primarily for custom sorting behavior, and
--   should be used in conjunction with <a>treeSortableSetSortColumnId</a>
--   to do that. For custom models, the mechanism will vary.
--   
--   The sort indicator changes direction to indicate normal sort or
--   reverse sort. Note that you must have the sort indicator enabled to
--   see anything when calling this function; see
--   <a>treeViewColumnSetSortIndicator</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetSortOrder :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> SortType -> m ()

-- | Sets the spacing field of <i><tt>treeColumn</tt></i>, which is the
--   number of pixels to place between cell renderers packed into it.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetSpacing :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Int32 -> m ()

-- | Sets the title of the <i><tt>treeColumn</tt></i>. If a custom widget
--   has been set, then this value is ignored.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetTitle :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Text -> m ()

-- | Sets the visibility of <i><tt>treeColumn</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetVisible :: (HasCallStack, MonadIO m, IsTreeViewColumn a) => a -> Bool -> m ()

-- | Sets the widget in the header to be <i><tt>widget</tt></i>. If widget
--   is <a>Nothing</a>, then the header button is set with a
--   <tt>GtkLabel</tt> set to the title of <i><tt>treeColumn</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkColumnView instead</i>
treeViewColumnSetWidget :: (HasCallStack, MonadIO m, IsTreeViewColumn a, IsWidget b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>alignment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnAlignment :: (IsTreeViewColumn o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #alignment
--   </pre>
getTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> m Float

-- | Set the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #alignment <a>:=</a> value ]
--   </pre>
setTreeViewColumnAlignment :: (MonadIO m, IsTreeViewColumn o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnCellArea :: (IsTreeViewColumn o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #cellArea
--   </pre>
getTreeViewColumnCellArea :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>clickable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnClickable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #clickable
--   </pre>
getTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #clickable <a>:=</a> value ]
--   </pre>
setTreeViewColumnClickable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnExpand :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #expand
--   </pre>
getTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #expand <a>:=</a> value ]
--   </pre>
setTreeViewColumnExpand :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fixed-width</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewColumnFixedWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #fixedWidth
--   </pre>
getTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #fixedWidth <a>:=</a> value ]
--   </pre>
setTreeViewColumnFixedWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnMaxWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #maxWidth
--   </pre>
getTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>max-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #maxWidth <a>:=</a> value ]
--   </pre>
setTreeViewColumnMaxWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnMinWidth :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #minWidth
--   </pre>
getTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>min-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #minWidth <a>:=</a> value ]
--   </pre>
setTreeViewColumnMinWidth :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewColumnReorderable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #reorderable
--   </pre>
getTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #reorderable <a>:=</a> value ]
--   </pre>
setTreeViewColumnReorderable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resizable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnResizable :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #resizable
--   </pre>
getTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #resizable <a>:=</a> value ]
--   </pre>
setTreeViewColumnResizable :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sizing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnSizing :: (IsTreeViewColumn o, MonadIO m) => TreeViewColumnSizing -> m (GValueConstruct o)

-- | Get the value of the “<tt>sizing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sizing
--   </pre>
getTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> m TreeViewColumnSizing

-- | Set the value of the “<tt>sizing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sizing <a>:=</a> value ]
--   </pre>
setTreeViewColumnSizing :: (MonadIO m, IsTreeViewColumn o) => o -> TreeViewColumnSizing -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-column-id</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewColumnSortColumnId :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-column-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sortColumnId
--   </pre>
getTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>sort-column-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sortColumnId <a>:=</a> value ]
--   </pre>
setTreeViewColumnSortColumnId :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-indicator</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewColumnSortIndicator :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-indicator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sortIndicator
--   </pre>
getTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>sort-indicator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sortIndicator <a>:=</a> value ]
--   </pre>
setTreeViewColumnSortIndicator :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-order</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeViewColumnSortOrder :: (IsTreeViewColumn o, MonadIO m) => SortType -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-order</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #sortOrder
--   </pre>
getTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> m SortType

-- | Set the value of the “<tt>sort-order</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #sortOrder <a>:=</a> value ]
--   </pre>
setTreeViewColumnSortOrder :: (MonadIO m, IsTreeViewColumn o) => o -> SortType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnSpacing :: (IsTreeViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #spacing
--   </pre>
getTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #spacing <a>:=</a> value ]
--   </pre>
setTreeViewColumnSpacing :: (MonadIO m, IsTreeViewColumn o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnTitle :: (IsTreeViewColumn o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #title
--   </pre>
getTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #title <a>:=</a> value ]
--   </pre>
setTreeViewColumnTitle :: (MonadIO m, IsTreeViewColumn o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnVisible :: (IsTreeViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #visible
--   </pre>
getTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #visible <a>:=</a> value ]
--   </pre>
setTreeViewColumnVisible :: (MonadIO m, IsTreeViewColumn o) => o -> Bool -> m ()

-- | Set the value of the “<tt>widget</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #widget
--   </pre>
clearTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>widget</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewColumnWidget :: (IsTreeViewColumn o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #widget
--   </pre>
getTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeViewColumn [ #widget <a>:=</a> value ]
--   </pre>
setTreeViewColumnWidget :: (MonadIO m, IsTreeViewColumn o, IsWidget a) => o -> a -> m ()

-- | Get the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #width
--   </pre>
getTreeViewColumnWidth :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Get the value of the “<tt>x-offset</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeViewColumn #xOffset
--   </pre>
getTreeViewColumnXOffset :: (MonadIO m, IsTreeViewColumn o) => o -> m Int32

-- | Emitted when the column's header has been clicked.
type TreeViewColumnClickedCallback = IO ()

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeViewColumn #clicked callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeViewColumn #clicked callback
--   </pre>
onTreeViewColumnClicked :: (IsTreeViewColumn a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnClickedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.TreeViewColumn.TreeViewColumn
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeViewColumn.TreeViewColumn
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeViewColumn.TreeViewColumn
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeViewColumn.TreeViewColumn)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeViewColumn.TreeViewColumn o) => GI.Gtk.Objects.TreeViewColumn.IsTreeViewColumn o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeViewColumn.TreeViewColumn
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeViewColumn.TreeViewColumn


-- | A widget for displaying both trees and lists
--   
--   &lt;picture&gt; &lt;source srcset="list-and-tree-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkTreeView" src="list-and-tree.png"&gt; &lt;/picture&gt;
--   
--   Widget that displays any object that implements the <a>TreeModel</a>
--   interface.
--   
--   Please refer to the <a>tree widget conceptual overview</a> for an
--   overview of all the objects and data types related to the tree widget
--   and how they work together.
--   
--   <h2>Coordinate systems in GtkTreeView API</h2>
--   
--   Several different coordinate systems are exposed in the
--   <tt>GtkTreeView</tt> API. These are:
--   
--   
--   <ul>
--   <li>Widget coordinates: Coordinates relative to the widget (usually
--   <tt>widget-&gt;window</tt>).</li>
--   <li>Bin window coordinates: Coordinates relative to the window that
--   GtkTreeView renders to.</li>
--   <li>Tree coordinates: Coordinates relative to the entire scrollable
--   area of GtkTreeView. These coordinates start at (0, 0) for row 0 of
--   the tree.</li>
--   </ul>
--   
--   Several functions are available for converting between the different
--   coordinate systems. The most common translations are between widget
--   and bin window coordinates and between bin window and tree
--   coordinates. For the former you can use
--   <a>treeViewConvertWidgetToBinWindowCoords</a> (and vice versa), for
--   the latter <a>treeViewConvertBinWindowToTreeCoords</a> (and vice
--   versa).
--   
--   <h2><tt>GtkTreeView</tt> as <tt>GtkBuildable</tt></h2>
--   
--   The <tt>GtkTreeView</tt> implementation of the <tt>GtkBuildable</tt>
--   interface accepts <a>TreeViewColumn</a> objects as
--   <tt>&lt;child&gt;</tt> elements and exposes the internal
--   <a>TreeSelection</a> in UI definitions.
--   
--   An example of a UI definition fragment with <tt>GtkTreeView</tt>:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkTreeView" id="treeview"&gt;
--     &lt;property name="model"&gt;liststore1&lt;/property&gt;
--     &lt;child&gt;
--       &lt;object class="GtkTreeViewColumn" id="test-column"&gt;
--         &lt;property name="title"&gt;Test&lt;/property&gt;
--         &lt;child&gt;
--           &lt;object class="GtkCellRendererText" id="test-renderer"/&gt;
--           &lt;attributes&gt;
--             &lt;attribute name="text"&gt;1&lt;/attribute&gt;
--           &lt;/attributes&gt;
--         &lt;/child&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;child internal-child="selection"&gt;
--       &lt;object class="GtkTreeSelection" id="selection"&gt;
--         &lt;signal name="changed" handler="on_treeview_selection_changed"/&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h2>CSS nodes</h2>
--   
--   <pre>
--   treeview.view
--   ├── header
--   │   ├── button
--   │   │   ╰── [sort-indicator]
--   ┊   ┊
--   │   ╰── button
--   │       ╰── [sort-indicator]
--   │
--   ├── [rubberband]
--   ╰── [dndtarget]
--   </pre>
--   
--   <tt>GtkTreeView</tt> has a main CSS node with name <tt>treeview</tt>
--   and style class <tt>.view</tt>. It has a subnode with name
--   <tt>header</tt>, which is the parent for all the column header
--   widgets' CSS nodes.
--   
--   Each column header consists of a <tt>button</tt>, which among other
--   content, has a child with name <tt>sort-indicator</tt>, which carries
--   the <tt>.ascending</tt> or <tt>.descending</tt> style classes when the
--   column header should show a sort indicator. The CSS is expected to
--   provide a suitable image using the <tt>-gtk-icon-source</tt> property.
--   
--   For rubberband selection, a subnode with name <tt>rubberband</tt> is
--   used.
--   
--   For the drop target location during DND, a subnode with name
--   <tt>dndtarget</tt> is used.
module GI.Gtk.Objects.TreeView

-- | Memory-managed wrapper type.
newtype TreeView
TreeView :: ManagedPtr TreeView -> TreeView

-- | Type class for types which can be safely cast to <a>TreeView</a>, for
--   instance with <a>toTreeView</a>.
class (GObject o, IsDescendantOf TreeView o) => IsTreeView o

-- | Cast to <a>TreeView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTreeView :: (MonadIO m, IsTreeView o) => o -> m TreeView

-- | Appends <i><tt>column</tt></i> to the list of columns. If
--   <i><tt>treeView</tt></i> has “fixed_height” mode enabled, then
--   <i><tt>column</tt></i> must have its “sizing” property set to be
--   GTK_TREE_VIEW_COLUMN_FIXED.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewAppendColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> b -> m Int32

-- | Recursively collapses all visible, expanded nodes in
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewCollapseAll :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Collapses a row (hides its child rows, if they exist).

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewCollapseRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m Bool

-- | Resizes all columns to their optimal width. Only works after the
--   treeview has been realized.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewColumnsAutosize :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Converts bin_window coordinates to coordinates for the tree (the full
--   scrollable area of the tree).

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewConvertBinWindowToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts bin_window coordinates to widget relative coordinates.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewConvertBinWindowToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts tree coordinates (coordinates in full scrollable area of the
--   tree) to bin_window coordinates.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewConvertTreeToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts tree coordinates (coordinates in full scrollable area of the
--   tree) to widget coordinates.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewConvertTreeToWidgetCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts widget coordinates to coordinates for the bin_window.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewConvertWidgetToBinWindowCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Converts widget coordinates to coordinates for the tree (the full
--   scrollable area of the tree).

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewConvertWidgetToTreeCoords :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Int32, Int32)

-- | Creates a <tt>cairo_surface_t</tt> representation of the row at
--   <i><tt>path</tt></i>. This image is used for a drag icon.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewCreateRowDragIcon :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m (Maybe Paintable)

-- | Turns <i><tt>treeView</tt></i> into a drop destination for automatic
--   DND. Calling this method sets <tt>GtkTreeView</tt>:reorderable to
--   <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewEnableModelDragDest :: (HasCallStack, MonadIO m, IsTreeView a) => a -> ContentFormats -> [DragAction] -> m ()

-- | Turns <i><tt>treeView</tt></i> into a drag source for automatic DND.
--   Calling this method sets <tt>GtkTreeView</tt>:reorderable to
--   <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewEnableModelDragSource :: (HasCallStack, MonadIO m, IsTreeView a) => a -> [ModifierType] -> ContentFormats -> [DragAction] -> m ()

-- | Recursively expands all nodes in the <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewExpandAll :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Opens the row so its children are visible.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewExpandRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> Bool -> m Bool

-- | Expands the row at <i><tt>path</tt></i>. This will also expand all
--   parent rows of <i><tt>path</tt></i> as necessary.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewExpandToPath :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m ()

-- | Gets the setting set by <a>treeViewSetActivateOnSingleClick</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Fills the bounding rectangle in bin_window coordinates for the cell at
--   the row specified by <i><tt>path</tt></i> and the column specified by
--   <i><tt>column</tt></i>. If <i><tt>path</tt></i> is <a>Nothing</a>, or
--   points to a node not found in the tree, the <i><tt>y</tt></i> and
--   <i><tt>height</tt></i> fields of the rectangle will be filled with 0.
--   If <i><tt>column</tt></i> is <a>Nothing</a>, the <i><tt>x</tt></i> and
--   <i><tt>width</tt></i> fields will be filled with 0. The returned
--   rectangle is equivalent to the <i><tt>backgroundArea</tt></i> passed
--   to <tt><i>gtk_cell_renderer_render()</i></tt>. These background areas
--   tile to cover the entire bin window. Contrast with the
--   <i><tt>cellArea</tt></i>, returned by <a>treeViewGetCellArea</a>,
--   which returns only the cell itself, excluding surrounding borders and
--   the tree expander area.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetBackgroundArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> m Rectangle

-- | Fills the bounding rectangle in bin_window coordinates for the cell at
--   the row specified by <i><tt>path</tt></i> and the column specified by
--   <i><tt>column</tt></i>. If <i><tt>path</tt></i> is <a>Nothing</a>, or
--   points to a path not currently displayed, the <i><tt>y</tt></i> and
--   <i><tt>height</tt></i> fields of the rectangle will be filled with 0.
--   If <i><tt>column</tt></i> is <a>Nothing</a>, the <i><tt>x</tt></i> and
--   <i><tt>width</tt></i> fields 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
--   <i><tt>cellArea</tt></i> passed to
--   <tt><i>gtk_cell_renderer_render()</i></tt>. This function is only
--   valid if <i><tt>treeView</tt></i> is realized.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetCellArea :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> m Rectangle

-- | Gets the <tt>GtkTreeViewColumn</tt> at the given position in the
--   <tt><i>tree_view</i></tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m (Maybe TreeViewColumn)

-- | Returns a <tt>GList</tt> of all the <tt>GtkTreeViewColumn</tt>s
--   currently in <i><tt>treeView</tt></i>. The returned list must be freed
--   with g_list_free ().

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetColumns :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m [TreeViewColumn]

-- | Fills in <i><tt>path</tt></i> and <i><tt>focusColumn</tt></i> with the
--   current path and focus column. If the cursor isn’t currently set, then
--   *<i><tt>path</tt></i> will be <a>Nothing</a>. If no column currently
--   has focus, then *<i><tt>focusColumn</tt></i> will be <a>Nothing</a>.
--   
--   The returned <tt>GtkTreePath</tt> must be freed with
--   <a>treePathFree</a> when you are done with it.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetCursor :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreePath, Maybe TreeViewColumn)

-- | Determines the destination row for a given position.
--   <i><tt>dragX</tt></i> and <i><tt>dragY</tt></i> are expected to be in
--   widget coordinates. This function is only meaningful if
--   <i><tt>treeView</tt></i> is realized. Therefore this function will
--   always return <a>False</a> if <i><tt>treeView</tt></i> is not realized
--   or does not have a model.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetDestRowAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, TreeViewDropPosition)

-- | Gets information about the row that is highlighted for feedback.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreePath, TreeViewDropPosition)

-- | Returns whether or not the tree allows to start interactive searching
--   by typing in text.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetEnableSearch :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether or not tree lines are drawn in
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetEnableTreeLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the column that is the current expander column, or
--   <a>Nothing</a> if none has been set. This column has the expander
--   arrow drawn next to it.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetExpanderColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreeViewColumn)

-- | Returns whether fixed height mode is turned on for
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetFixedHeightMode :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns which grid lines are enabled in <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetGridLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m TreeViewGridLines

-- | Returns whether all header columns are clickable.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetHeadersClickable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns <a>True</a> if the headers on the <i><tt>treeView</tt></i> are
--   visible.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetHeadersVisible :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether hover expansion mode is turned on for
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetHoverExpand :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether hover selection mode is turned on for
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetHoverSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the amount, in pixels, of extra indentation for child levels
--   in <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetLevelIndentation :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | Returns the model the <tt>GtkTreeView</tt> is based on. Returns
--   <a>Nothing</a> if the model is unset.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetModel :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe TreeModel)

-- | Queries the number of columns in the given <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetNColumns :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Word32

-- | Finds the path at the point (<i><tt>x</tt></i>, <i><tt>y</tt></i>),
--   relative to bin_window coordinates. That is, <i><tt>x</tt></i> and
--   <i><tt>y</tt></i> are relative to an events coordinates.
--   Widget-relative coordinates must be converted using
--   <a>treeViewConvertWidgetToBinWindowCoords</a>. It is primarily for
--   things like popup menus. If <i><tt>path</tt></i> is
--   non-<a>Nothing</a>, then it will be filled with the
--   <tt>GtkTreePath</tt> at that point. This path should be freed with
--   <a>treePathFree</a>. If <i><tt>column</tt></i> is non-<a>Nothing</a>,
--   then it will be filled with the column at that point.
--   <i><tt>cellX</tt></i> and <i><tt>cellY</tt></i> return the coordinates
--   relative to the cell background (i.e. the
--   <i><tt>backgroundArea</tt></i> passed to
--   <tt><i>gtk_cell_renderer_render()</i></tt>). This function is only
--   meaningful if <i><tt>treeView</tt></i> is realized. Therefore this
--   function will always return <a>False</a> if <i><tt>treeView</tt></i>
--   is not realized or does not have a model.
--   
--   For converting widget coordinates (eg. the ones you get from
--   GtkWidget<a>queryTooltip</a>), please see
--   <a>treeViewConvertWidgetToBinWindowCoords</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetPathAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32)

-- | Retrieves whether the user can reorder the tree via drag-and-drop. See
--   <a>treeViewSetReorderable</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetReorderable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns whether rubber banding is turned on for
--   <i><tt>treeView</tt></i>. If the selection mode is
--   <a>SelectionModeMultiple</a>, rubber banding will allow the user to
--   select multiple rows by dragging the mouse.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetRubberBanding :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Gets the column searched on by the interactive search code.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetSearchColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | Returns the <tt>GtkEntry</tt> which is currently in use as interactive
--   search entry for <i><tt>treeView</tt></i>. In case the built-in entry
--   is being used, <a>Nothing</a> will be returned.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Maybe Editable)

-- | Gets the <tt>GtkTreeSelection</tt> associated with
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m TreeSelection

-- | Returns whether or not expanders are drawn in
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetShowExpanders :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Returns the column of <i><tt>treeView</tt></i>’s model which is being
--   used for displaying tooltips on <i><tt>treeView</tt></i>’s rows.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetTooltipColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Int32

-- | This function is supposed to be used in a <a>queryTooltip</a> signal
--   handler for <tt>GtkTreeView</tt>. The <i><tt>x</tt></i>,
--   <i><tt>y</tt></i> and <i><tt>keyboardTip</tt></i> values which are
--   received in the signal handler, should be passed to this function
--   without modification.
--   
--   The return value indicates whether there is a tree view row at the
--   given coordinates (<a>True</a>) or not (<a>False</a>) for mouse
--   tooltips. For keyboard tooltips the row returned will be the cursor
--   row. When <a>True</a>, then any of <i><tt>model</tt></i>,
--   <i><tt>path</tt></i> and <i><tt>iter</tt></i> which have been provided
--   will be set to point to that row and the corresponding model.
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> will always be converted to be
--   relative to <i><tt>treeView</tt></i>’s bin_window if
--   <i><tt>keyboardTooltip</tt></i> is <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetTooltipContext :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, Maybe TreeModel, TreePath, TreeIter)

-- | Sets <i><tt>startPath</tt></i> and <i><tt>endPath</tt></i> to be the
--   first and last visible path. Note that there may be invisible paths in
--   between.
--   
--   The paths should be freed with <a>treePathFree</a> after use.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetVisibleRange :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m (Bool, TreePath, TreePath)

-- | Fills <i><tt>visibleRect</tt></i> with the currently-visible region of
--   the buffer, in tree coordinates. Convert to bin_window coordinates
--   with <a>treeViewConvertTreeToBinWindowCoords</a>. Tree coordinates
--   start at 0,0 for row 0 of the tree, and cover the entire scrollable
--   area of the tree.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Rectangle

-- | This inserts the <i><tt>column</tt></i> into the
--   <i><tt>treeView</tt></i> at <i><tt>position</tt></i>. If
--   <i><tt>position</tt></i> is -1, then the column is inserted at the
--   end. If <i><tt>treeView</tt></i> has “fixed_height” mode enabled, then
--   <i><tt>column</tt></i> must have its “sizing” property set to be
--   GTK_TREE_VIEW_COLUMN_FIXED.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewInsertColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> b -> Int32 -> m Int32

-- | Convenience function that inserts a new column into the
--   <tt>GtkTreeView</tt> with the given cell renderer and a
--   <tt>GtkTreeCellDataFunc</tt> to set cell renderer attributes (normally
--   using data from the model). See also
--   <a>treeViewColumnSetCellDataFunc</a>, <a>treeViewColumnPackStart</a>.
--   If <i><tt>treeView</tt></i> has “fixed_height” mode enabled, then the
--   new column will have its “sizing” property set to be
--   GTK_TREE_VIEW_COLUMN_FIXED.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewInsertColumnWithDataFunc :: (HasCallStack, MonadIO m, IsTreeView a, IsCellRenderer b) => a -> Int32 -> Text -> b -> TreeCellDataFunc -> m Int32

-- | Determine whether the point (<i><tt>x</tt></i>, <i><tt>y</tt></i>) in
--   <i><tt>treeView</tt></i> is blank, that is no cell content nor an
--   expander arrow is drawn at the location. If so, the location can be
--   considered as the background. You might wish to take special action on
--   clicks on the background, such as clearing a current selection, having
--   a custom context menu or starting rubber banding.
--   
--   The <i><tt>x</tt></i> and <i><tt>y</tt></i> coordinate that are
--   provided must be relative to bin_window coordinates. Widget-relative
--   coordinates must be converted using
--   <a>treeViewConvertWidgetToBinWindowCoords</a>.
--   
--   For converting widget coordinates (eg. the ones you get from
--   GtkWidget<a>queryTooltip</a>), please see
--   <a>treeViewConvertWidgetToBinWindowCoords</a>.
--   
--   The <i><tt>path</tt></i>, <i><tt>column</tt></i>,
--   <i><tt>cellX</tt></i> and <i><tt>cellY</tt></i> arguments will be
--   filled in likewise as for <a>treeViewGetPathAtPos</a>. Please see
--   <a>treeViewGetPathAtPos</a> for more information.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewIsBlankAtPos :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m (Bool, Maybe TreePath, Maybe TreeViewColumn, Int32, Int32)

-- | Returns whether a rubber banding operation is currently being done in
--   <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewIsRubberBandingActive :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m Bool

-- | Calls <i><tt>func</tt></i> on all expanded rows.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewMapExpandedRows :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewMappingFunc -> m ()

-- | Moves <i><tt>column</tt></i> to be after to
--   <i><tt>baseColumn</tt></i>. If <i><tt>baseColumn</tt></i> is
--   <a>Nothing</a>, then <i><tt>column</tt></i> is placed in the first
--   position.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewMoveColumnAfter :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsTreeViewColumn c) => a -> b -> Maybe c -> m ()

-- | Creates a new <tt>GtkTreeView</tt> widget.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewNew :: (HasCallStack, MonadIO m) => m TreeView

-- | Creates a new <tt>GtkTreeView</tt> widget with the model initialized
--   to <i><tt>model</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m TreeView

-- | Removes <i><tt>column</tt></i> from <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewRemoveColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> b -> m Int32

-- | Activates the cell determined by <i><tt>path</tt></i> and
--   <i><tt>column</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewRowActivated :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> TreePath -> Maybe b -> m ()

-- | Returns <a>True</a> if the node pointed to by <i><tt>path</tt></i> is
--   expanded in <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewRowExpanded :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreePath -> m Bool

-- | Moves the alignments of <i><tt>treeView</tt></i> to the position
--   specified by <i><tt>column</tt></i> and <i><tt>path</tt></i>. If
--   <i><tt>column</tt></i> is <a>Nothing</a>, then no horizontal scrolling
--   occurs. Likewise, if <i><tt>path</tt></i> is <a>Nothing</a> no
--   vertical scrolling occurs. At a minimum, one of <i><tt>column</tt></i>
--   or <i><tt>path</tt></i> need to be non-<a>Nothing</a>.
--   <i><tt>rowAlign</tt></i> determines where the row is placed, and
--   <i><tt>colAlign</tt></i> determines where <i><tt>column</tt></i> is
--   placed. Both are expected to be between 0.0 and 1.0. 0.0 means
--   left/top alignment, 1.0 means right/bottom alignment, 0.5 means
--   center.
--   
--   If <i><tt>useAlign</tt></i> is <a>False</a>, then the alignment
--   arguments are ignored, and the tree does the minimum amount of work to
--   scroll the cell onto the screen. This means that the cell will be
--   scrolled to the edge closest to its current position. If the cell is
--   currently visible on the screen, nothing is done.
--   
--   This function only works if the model is set, and <i><tt>path</tt></i>
--   is a valid row on the model. If the model changes before the
--   <i><tt>treeView</tt></i> is realized, the centered path will be
--   modified to reflect this change.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewScrollToCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe TreePath -> Maybe b -> Bool -> Float -> Float -> m ()

-- | Scrolls the tree view such that the top-left corner of the visible
--   area is <i><tt>treeX</tt></i>, <i><tt>treeY</tt></i>, where
--   <i><tt>treeX</tt></i> and <i><tt>treeY</tt></i> are specified in tree
--   coordinates. The <i><tt>treeView</tt></i> must be realized before this
--   function is called. If it isn't, you probably want to be using
--   <a>treeViewScrollToCell</a>.
--   
--   If either <i><tt>treeX</tt></i> or <i><tt>treeY</tt></i> are -1, then
--   that direction isn’t scrolled.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewScrollToPoint :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> Int32 -> m ()

-- | Cause the <tt>GtkTreeView</tt><a>rowActivated</a> signal to be emitted
--   on a single click instead of a double click.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets a user function for determining where a column may be dropped
--   when dragged. This function is called on every column pair in turn at
--   the beginning of a column drag to determine where a drop can take
--   place. The arguments passed to <i><tt>func</tt></i> are: the
--   <i><tt>treeView</tt></i>, the <tt>GtkTreeViewColumn</tt> being
--   dragged, the two <tt>GtkTreeViewColumn</tt>s determining the drop
--   spot, and <i><tt>userData</tt></i>. If either of the
--   <tt>GtkTreeViewColumn</tt> arguments for the drop spot are
--   <a>Nothing</a>, then they indicate an edge. If <i><tt>func</tt></i> is
--   set to be <a>Nothing</a>, then <i><tt>treeView</tt></i> reverts to the
--   default behavior of allowing all columns to be dropped everywhere.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetColumnDragFunction :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewColumnDropFunc -> m ()

-- | Sets the current keyboard focus to be at <i><tt>path</tt></i>, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular row. If <i><tt>focusColumn</tt></i> is not
--   <a>Nothing</a>, then focus is given to the column specified by it.
--   Additionally, if <i><tt>focusColumn</tt></i> is specified, and
--   <i><tt>startEditing</tt></i> is <a>True</a>, then editing should be
--   started in the specified cell. This function is often followed by
--   <i><tt>gtkWidgetGrabFocus</tt></i> (<i><tt>treeView</tt></i>) in order
--   to give keyboard focus to the widget. Please note that editing can
--   only happen when the widget is realized.
--   
--   If <i><tt>path</tt></i> is invalid for <i><tt>model</tt></i>, the
--   current cursor (if any) will be unset and the function will return
--   without failing.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetCursor :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> TreePath -> Maybe b -> Bool -> m ()

-- | Sets the current keyboard focus to be at <i><tt>path</tt></i>, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular row. If <i><tt>focusColumn</tt></i> is not
--   <a>Nothing</a>, then focus is given to the column specified by it. If
--   <i><tt>focusColumn</tt></i> and <i><tt>focusCell</tt></i> are not
--   <a>Nothing</a>, and <i><tt>focusColumn</tt></i> contains 2 or more
--   editable or activatable cells, then focus is given to the cell
--   specified by <i><tt>focusCell</tt></i>. Additionally, if
--   <i><tt>focusColumn</tt></i> is specified, and
--   <i><tt>startEditing</tt></i> is <a>True</a>, then editing should be
--   started in the specified cell. This function is often followed by
--   <i><tt>gtkWidgetGrabFocus</tt></i> (<i><tt>treeView</tt></i>) in order
--   to give keyboard focus to the widget. Please note that editing can
--   only happen when the widget is realized.
--   
--   If <i><tt>path</tt></i> is invalid for <i><tt>model</tt></i>, the
--   current cursor (if any) will be unset and the function will return
--   without failing.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetCursorOnCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b, IsCellRenderer c) => a -> TreePath -> Maybe b -> Maybe c -> Bool -> m ()

-- | Sets the row that is highlighted for feedback. If <i><tt>path</tt></i>
--   is <a>Nothing</a>, an existing highlight is removed.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetDragDestRow :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreePath -> TreeViewDropPosition -> m ()

-- | If <i><tt>enableSearch</tt></i> is set, then the user can type in text
--   to search through the tree interactively (this is sometimes called
--   "typeahead find").
--   
--   Note that even if this is <a>False</a>, the user can still initiate a
--   search using the “start-interactive-search” key binding.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetEnableSearch :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets whether to draw lines interconnecting the expanders in
--   <i><tt>treeView</tt></i>. This does not have any visible effects for
--   lists.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetEnableTreeLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the column to draw the expander arrow at. It must be in
--   <i><tt>treeView</tt></i>. If <i><tt>column</tt></i> is <a>Nothing</a>,
--   then the expander arrow is always at the first visible column.
--   
--   If you do not want expander arrow to appear in your tree, set the
--   expander column to a hidden column.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetExpanderColumn :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeViewColumn b) => a -> Maybe b -> m ()

-- | Enables or disables the fixed height mode of <i><tt>treeView</tt></i>.
--   Fixed height mode speeds up <tt>GtkTreeView</tt> by assuming that all
--   rows have the same height. Only enable this option if all rows are the
--   same height and all columns are of type
--   <a>TreeViewColumnSizingFixed</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetFixedHeightMode :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets which grid lines to draw in <i><tt>treeView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetGridLines :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewGridLines -> m ()

-- | Allow the column title buttons to be clicked.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetHeadersClickable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the visibility state of the headers.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetHeadersVisible :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Enables or disables the hover expansion mode of
--   <i><tt>treeView</tt></i>. Hover expansion makes rows expand or
--   collapse if the pointer moves over them.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetHoverExpand :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Enables or disables the hover selection mode of
--   <i><tt>treeView</tt></i>. Hover selection makes the selected row
--   follow the pointer. Currently, this works only for the selection modes
--   <a>SelectionModeSingle</a> and <a>SelectionModeBrowse</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetHoverSelection :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the amount of extra indentation for child levels to use in
--   <i><tt>treeView</tt></i> in addition to the default indentation. The
--   value should be specified in pixels, a value of 0 disables this
--   feature and in this case only the default indentation will be used.
--   This does not have any visible effects for lists.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetLevelIndentation :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Sets the model for a <tt>GtkTreeView</tt>. If the
--   <i><tt>treeView</tt></i> already has a model set, it will remove it
--   before setting the new model. If <i><tt>model</tt></i> is
--   <a>Nothing</a>, then it will unset the old model.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetModel :: (HasCallStack, MonadIO m, IsTreeView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | This function is a convenience function to allow you to reorder models
--   that support the <tt>GtkTreeDragSourceIface</tt> and the
--   <tt>GtkTreeDragDestIface</tt>. Both <tt>GtkTreeStore</tt> and
--   <tt>GtkListStore</tt> support these. If <i><tt>reorderable</tt></i> is
--   <a>True</a>, then the user can reorder the model by dragging and
--   dropping rows. The developer can listen to these changes by connecting
--   to the model’s <tt>GtkTreeModel::row-inserted</tt> and
--   <tt>GtkTreeModel::row-deleted</tt> signals. The reordering is
--   implemented by setting up the tree view as a drag source and
--   destination. Therefore, drag and drop can not be used in a reorderable
--   view for any other purpose.
--   
--   This function does not give you any degree of control over the order
--   -- any reordering is allowed. If more control is needed, you should
--   probably handle drag and drop manually.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetReorderable :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the row separator function, which is used to determine whether a
--   row should be drawn as a separator. If the row separator function is
--   <a>Nothing</a>, no separators are drawn. This is the default value.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Maybe TreeViewRowSeparatorFunc -> m ()

-- | Enables or disables rubber banding in <i><tt>treeView</tt></i>. If the
--   selection mode is <a>SelectionModeMultiple</a>, rubber banding will
--   allow the user to select multiple rows by dragging the mouse.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetRubberBanding :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets <i><tt>column</tt></i> as the column where the interactive search
--   code should search in for the current model.
--   
--   If the search column is set, users can use the
--   “start-interactive-search” key binding to bring up search popup. The
--   enable-search property controls whether simply typing text will also
--   start an interactive search.
--   
--   Note that <i><tt>column</tt></i> refers to a column of the current
--   model. The search column is reset to -1 when the model is changed.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetSearchColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Sets the entry which the interactive search code will use for this
--   <i><tt>treeView</tt></i>. This is useful when you want to provide a
--   search entry in our interface at all time at a fixed position. Passing
--   <a>Nothing</a> for <i><tt>entry</tt></i> will make the interactive
--   search code use the built-in popup entry again.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetSearchEntry :: (HasCallStack, MonadIO m, IsTreeView a, IsEditable b) => a -> Maybe b -> m ()

-- | Sets the compare function for the interactive search capabilities;
--   note that somewhat like <tt><i>strcmp()</i></tt> returning 0 for
--   equality <tt>GtkTreeView</tt>SearchEqualFunc returns <a>False</a> on
--   matches.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetSearchEqualFunc :: (HasCallStack, MonadIO m, IsTreeView a) => a -> TreeViewSearchEqualFunc -> m ()

-- | Sets whether to draw and enable expanders and indent child rows in
--   <i><tt>treeView</tt></i>. When disabled there will be no expanders
--   visible in trees and there will be no way to expand and collapse rows
--   by default. Also note that hiding the expanders will disable the
--   default indentation. You can set a custom indentation in this case
--   using <a>treeViewSetLevelIndentation</a>. This does not have any
--   visible effects for lists.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetShowExpanders :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Bool -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to the area
--   <i><tt>path</tt></i>, <i><tt>column</tt></i> and <i><tt>cell</tt></i>
--   have in common. For example if <i><tt>path</tt></i> is <a>Nothing</a>
--   and <i><tt>column</tt></i> is set, the tip area will be set to the
--   full area covered by <i><tt>column</tt></i>. See also
--   <a>tooltipSetTipArea</a>.
--   
--   Note that if <i><tt>path</tt></i> is not specified and
--   <i><tt>cell</tt></i> is set and part of a column containing the
--   expander, the tooltip might not show and hide at the correct position.
--   In such cases <i><tt>path</tt></i> must be set to the current node
--   under the mouse cursor for this function to operate correctly.
--   
--   See also <a>treeViewSetTooltipColumn</a> for a simpler alternative.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetTooltipCell :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b, IsTreeViewColumn c, IsCellRenderer d) => a -> b -> Maybe TreePath -> Maybe c -> Maybe d -> m ()

-- | If you only plan to have simple (text-only) tooltips on full rows, you
--   can use this function to have <tt>GtkTreeView</tt> handle these
--   automatically for you. <i><tt>column</tt></i> should be set to the
--   column in <i><tt>treeView</tt></i>’s model containing the tooltip
--   texts, or -1 to disable this feature.
--   
--   When enabled, <tt>GtkWidget:has-tooltip</tt> will be set to
--   <a>True</a> and <i><tt>treeView</tt></i> will connect a
--   <tt>GtkWidget::query-tooltip</tt> signal handler.
--   
--   Note that the signal handler sets the text with
--   <a>tooltipSetMarkup</a>, so &amp;, &lt;, etc have to be escaped in the
--   text.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetTooltipColumn :: (HasCallStack, MonadIO m, IsTreeView a) => a -> Int32 -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to be the area covered by
--   the row at <i><tt>path</tt></i>. See also
--   <a>treeViewSetTooltipColumn</a> for a simpler alternative. See also
--   <a>tooltipSetTipArea</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewSetTooltipRow :: (HasCallStack, MonadIO m, IsTreeView a, IsTooltip b) => a -> b -> TreePath -> m ()

-- | Undoes the effect of <a>treeViewEnableModelDragDest</a>. Calling this
--   method sets <tt>GtkTreeView</tt>:reorderable to <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewUnsetRowsDragDest :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Undoes the effect of <a>treeViewEnableModelDragSource</a>. Calling
--   this method sets <tt>GtkTreeView</tt>:reorderable to <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListView</a> or
--   <a>ColumnView</a> instead</i>
treeViewUnsetRowsDragSource :: (HasCallStack, MonadIO m, IsTreeView a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTreeViewActivateOnSingleClick :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #activateOnSingleClick
--   </pre>
getTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setTreeViewActivateOnSingleClick :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-grid-lines</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewEnableGridLines :: (IsTreeView o, MonadIO m) => TreeViewGridLines -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-grid-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #enableGridLines
--   </pre>
getTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> m TreeViewGridLines

-- | Set the value of the “<tt>enable-grid-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #enableGridLines <a>:=</a> value ]
--   </pre>
setTreeViewEnableGridLines :: (MonadIO m, IsTreeView o) => o -> TreeViewGridLines -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-search</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewEnableSearch :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #enableSearch
--   </pre>
getTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>enable-search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #enableSearch <a>:=</a> value ]
--   </pre>
setTreeViewEnableSearch :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-tree-lines</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewEnableTreeLines :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-tree-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #enableTreeLines
--   </pre>
getTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>enable-tree-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #enableTreeLines <a>:=</a> value ]
--   </pre>
setTreeViewEnableTreeLines :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Set the value of the “<tt>expander-column</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #expanderColumn
--   </pre>
clearTreeViewExpanderColumn :: (MonadIO m, IsTreeView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expander-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewExpanderColumn :: (IsTreeView o, MonadIO m, IsTreeViewColumn a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>expander-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #expanderColumn
--   </pre>
getTreeViewExpanderColumn :: (MonadIO m, IsTreeView o) => o -> m (Maybe TreeViewColumn)

-- | Set the value of the “<tt>expander-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #expanderColumn <a>:=</a> value ]
--   </pre>
setTreeViewExpanderColumn :: (MonadIO m, IsTreeView o, IsTreeViewColumn a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fixed-height-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewFixedHeightMode :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fixed-height-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #fixedHeightMode
--   </pre>
getTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>fixed-height-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #fixedHeightMode <a>:=</a> value ]
--   </pre>
setTreeViewFixedHeightMode :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>headers-clickable</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewHeadersClickable :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>headers-clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #headersClickable
--   </pre>
getTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>headers-clickable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #headersClickable <a>:=</a> value ]
--   </pre>
setTreeViewHeadersClickable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>headers-visible</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewHeadersVisible :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>headers-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #headersVisible
--   </pre>
getTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>headers-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #headersVisible <a>:=</a> value ]
--   </pre>
setTreeViewHeadersVisible :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hover-expand</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewHoverExpand :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hover-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #hoverExpand
--   </pre>
getTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>hover-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #hoverExpand <a>:=</a> value ]
--   </pre>
setTreeViewHoverExpand :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hover-selection</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewHoverSelection :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hover-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #hoverSelection
--   </pre>
getTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>hover-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #hoverSelection <a>:=</a> value ]
--   </pre>
setTreeViewHoverSelection :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>level-indentation</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewLevelIndentation :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>level-indentation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #levelIndentation
--   </pre>
getTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “<tt>level-indentation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #levelIndentation <a>:=</a> value ]
--   </pre>
setTreeViewLevelIndentation :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeViewModel :: (IsTreeView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #model
--   </pre>
getTreeViewModel :: (MonadIO m, IsTreeView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #model <a>:=</a> value ]
--   </pre>
setTreeViewModel :: (MonadIO m, IsTreeView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewReorderable :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #reorderable
--   </pre>
getTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #reorderable <a>:=</a> value ]
--   </pre>
setTreeViewReorderable :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rubber-banding</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewRubberBanding :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>rubber-banding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #rubberBanding
--   </pre>
getTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>rubber-banding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #rubberBanding <a>:=</a> value ]
--   </pre>
setTreeViewRubberBanding :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeViewSearchColumn :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>search-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #searchColumn
--   </pre>
getTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “<tt>search-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #searchColumn <a>:=</a> value ]
--   </pre>
setTreeViewSearchColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-expanders</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewShowExpanders :: (IsTreeView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-expanders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #showExpanders
--   </pre>
getTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> m Bool

-- | Set the value of the “<tt>show-expanders</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #showExpanders <a>:=</a> value ]
--   </pre>
setTreeViewShowExpanders :: (MonadIO m, IsTreeView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeViewTooltipColumn :: (IsTreeView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeView #tooltipColumn
--   </pre>
getTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> m Int32

-- | Set the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeView [ #tooltipColumn <a>:=</a> value ]
--   </pre>
setTreeViewTooltipColumn :: (MonadIO m, IsTreeView o) => o -> Int32 -> m ()

-- | The number of columns of the treeview has changed.
type TreeViewColumnsChangedCallback = IO ()

-- | Connect a signal handler for the <a>columnsChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #columnsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewColumnsChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>columnsChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #columnsChanged callback
--   </pre>
onTreeViewColumnsChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewColumnsChangedCallback) -> m SignalHandlerId

-- | The position of the cursor (focused cell) has changed.
type TreeViewCursorChangedCallback = IO ()

-- | Connect a signal handler for the <a>cursorChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #cursorChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewCursorChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewCursorChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cursorChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #cursorChanged callback
--   </pre>
onTreeViewCursorChanged :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewCursorChangedCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
type TreeViewExpandCollapseCursorRowCallback = Bool -> Bool -> Bool -> IO Bool

-- | Connect a signal handler for the <a>expandCollapseCursorRow</a>
--   signal, to be run after the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #expandCollapseCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewExpandCollapseCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewExpandCollapseCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>expandCollapseCursorRow</a>
--   signal, to be run before the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #expandCollapseCursorRow callback
--   </pre>
onTreeViewExpandCollapseCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewExpandCollapseCursorRowCallback) -> m SignalHandlerId

-- | The <tt>GtkTreeView</tt><a>moveCursor</a> signal is a [keybinding
--   signal]t<a>SignalAction</a> which gets emitted when the user presses
--   one of the cursor keys.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically. In contrast to <a>treeViewSetCursor</a> and
--   <a>treeViewSetCursorOnCell</a> when moving horizontally
--   <tt>GtkTreeView</tt><a>moveCursor</a> does not reset the current
--   selection.
type TreeViewMoveCursorCallback = MovementStep -> Int32 -> Bool -> Bool -> IO Bool

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewMoveCursor :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #moveCursor callback
--   </pre>
onTreeViewMoveCursor :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewMoveCursorCallback) -> m SignalHandlerId

-- | The "row-activated" signal is emitted when the method
--   <a>treeViewRowActivated</a> is called.
--   
--   This signal is emitted when the user double-clicks a treeview row with
--   the <a>TreeView:activateOnSingleClick</a> property set to
--   <a>False</a>, or when the user single-clicks a row when that property
--   set to <a>True</a>.
--   
--   This signal is also emitted when a non-editable row is selected and
--   one of the keys: &lt;kbd&gt;Space&lt;/kbd&gt;,
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt;,
--   &lt;kbd&gt;Return&lt;/kbd&gt; or &lt;kbd&gt;Enter&lt;/kbd&gt; is
--   pressed.
--   
--   For selection handling refer to the <a>tree widget conceptual
--   overview</a> as well as <tt>GtkTreeSelection</tt>.
type TreeViewRowActivatedCallback = TreePath -> Maybe TreeViewColumn -> IO ()

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #rowActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewRowActivated :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #rowActivated callback
--   </pre>
onTreeViewRowActivated :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowActivatedCallback) -> m SignalHandlerId

-- | The given row has been collapsed (child nodes are hidden).
type TreeViewRowCollapsedCallback = TreeIter -> TreePath -> IO ()

-- | Connect a signal handler for the <a>rowCollapsed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #rowCollapsed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewRowCollapsed :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowCollapsedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowCollapsed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #rowCollapsed callback
--   </pre>
onTreeViewRowCollapsed :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowCollapsedCallback) -> m SignalHandlerId

-- | The given row has been expanded (child nodes are shown).
type TreeViewRowExpandedCallback = TreeIter -> TreePath -> IO ()

-- | Connect a signal handler for the <a>rowExpanded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #rowExpanded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewRowExpanded :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowExpandedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowExpanded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #rowExpanded callback
--   </pre>
onTreeViewRowExpanded :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewRowExpandedCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
type TreeViewSelectAllCallback = IO Bool

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewSelectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #selectAll callback
--   </pre>
onTreeViewSelectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectAllCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
type TreeViewSelectCursorParentCallback = IO Bool

-- | Connect a signal handler for the <a>selectCursorParent</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #selectCursorParent callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewSelectCursorParent :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorParentCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorParent</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #selectCursorParent callback
--   </pre>
onTreeViewSelectCursorParent :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorParentCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
type TreeViewSelectCursorRowCallback = Bool -> IO Bool

-- | Connect a signal handler for the <a>selectCursorRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #selectCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewSelectCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #selectCursorRow callback
--   </pre>
onTreeViewSelectCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewSelectCursorRowCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
type TreeViewStartInteractiveSearchCallback = IO Bool

-- | Connect a signal handler for the <a>startInteractiveSearch</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #startInteractiveSearch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewStartInteractiveSearch :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewStartInteractiveSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>startInteractiveSearch</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #startInteractiveSearch callback
--   </pre>
onTreeViewStartInteractiveSearch :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewStartInteractiveSearchCallback) -> m SignalHandlerId

-- | The given row is about to be collapsed (hide its children nodes). Use
--   this signal if you need to control the collapsibility of individual
--   rows.
type TreeViewTestCollapseRowCallback = TreeIter -> TreePath -> IO Bool

-- | Connect a signal handler for the <a>testCollapseRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #testCollapseRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewTestCollapseRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestCollapseRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>testCollapseRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #testCollapseRow callback
--   </pre>
onTreeViewTestCollapseRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestCollapseRowCallback) -> m SignalHandlerId

-- | The given row is about to be expanded (show its children nodes). Use
--   this signal if you need to control the expandability of individual
--   rows.
type TreeViewTestExpandRowCallback = TreeIter -> TreePath -> IO Bool

-- | Connect a signal handler for the <a>testExpandRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #testExpandRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewTestExpandRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestExpandRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>testExpandRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #testExpandRow callback
--   </pre>
onTreeViewTestExpandRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewTestExpandRowCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
type TreeViewToggleCursorRowCallback = IO Bool

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeView #toggleCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewToggleCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #toggleCursorRow callback
--   </pre>
onTreeViewToggleCursorRow :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewToggleCursorRowCallback) -> m SignalHandlerId

-- | <i>No description available in the introspection data.</i>
type TreeViewUnselectAllCallback = IO Bool

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeView #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeViewUnselectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeView #unselectAll callback
--   </pre>
onTreeViewUnselectAll :: (IsTreeView a, MonadIO m) => a -> ((?self :: a) => TreeViewUnselectAllCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.TreeView.TreeView
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeView.TreeView
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeView.TreeView
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeView.TreeView)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeView.TreeView o) => GI.Gtk.Objects.TreeView.IsTreeView o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeView.TreeView
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeView.TreeView


-- | A tree-like data structure that can be used with the <a>TreeView</a>.
--   
--   The <tt>GtkTreeStore</tt> object is a list model for use with a
--   <tt>GtkTreeView</tt> widget. It implements the <a>TreeModel</a>
--   interface, and consequently, can use all of the methods available
--   there. It also implements the <a>TreeSortable</a> interface so it can
--   be sorted by the view. Finally, it also implements the tree
--   [drag]t<a>TreeDragSource</a> and [drop]t<a>TreeDragDest</a>
--   interfaces.
--   
--   <tt>GtkTreeStore</tt> is deprecated since GTK 4.10, and should not be
--   used in newly written code. You should use <a>TreeListModel</a> for a
--   tree-like model object.
--   
--   <h2>GtkTreeStore as GtkBuildable</h2>
--   
--   The GtkTreeStore implementation of the <tt>GtkBuildable</tt> interface
--   allows to specify the model columns with a <tt>&lt;columns&gt;</tt>
--   element that may contain multiple <tt>&lt;column&gt;</tt> elements,
--   each specifying one model column. The “type” attribute specifies the
--   data type for the column.
--   
--   An example of a UI Definition fragment for a tree store:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkTreeStore"&gt;
--     &lt;columns&gt;
--       &lt;column type="gchararray"/&gt;
--       &lt;column type="gchararray"/&gt;
--       &lt;column type="gint"/&gt;
--     &lt;/columns&gt;
--   &lt;/object&gt;
--   </pre>
module GI.Gtk.Objects.TreeStore

-- | Memory-managed wrapper type.
newtype TreeStore
TreeStore :: ManagedPtr TreeStore -> TreeStore

-- | Type class for types which can be safely cast to <a>TreeStore</a>, for
--   instance with <a>toTreeStore</a>.
class (GObject o, IsDescendantOf TreeStore o) => IsTreeStore o

-- | Cast to <a>TreeStore</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeStore :: (MonadIO m, IsTreeStore o) => o -> m TreeStore

-- | Appends a new row to <i><tt>treeStore</tt></i>.
--   
--   If <i><tt>parent</tt></i> is non-<a>Nothing</a>, then it will append
--   the new row after the last child of <i><tt>parent</tt></i>, otherwise
--   it will append a row to the top level.
--   
--   The <i><tt>iter</tt></i> parameter will be changed to point to this
--   new row. The row will be empty after this function is called. To fill
--   in values, you need to call <tt><i>gtk_tree_store_set()</i></tt> or
--   <a>treeStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreAppend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Removes all rows from <i><tt>treeStore</tt></i>

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreClear :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> m ()

-- | Creates a new row at <i><tt>position</tt></i>.
--   
--   If parent is non-<a>Nothing</a>, then the row will be made a child of
--   <i><tt>parent</tt></i>. Otherwise, the row will be created at the
--   toplevel.
--   
--   If <i><tt>position</tt></i> is <tt>-1</tt> or is larger than the
--   number of rows at that level, then the new row will be inserted to the
--   end of the list.
--   
--   The <i><tt>iter</tt></i> parameter will be changed to point to this
--   new row. The row will be empty after this function is called. To fill
--   in values, you need to call <tt><i>gtk_tree_store_set()</i></tt> or
--   <a>treeStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreInsert :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> m TreeIter

-- | Inserts a new row after <i><tt>sibling</tt></i>.
--   
--   If <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   prepended to <i><tt>parent</tt></i>’s children.
--   
--   If <i><tt>parent</tt></i> and <i><tt>sibling</tt></i> are
--   <a>Nothing</a>, then the row will be prepended to the toplevel.
--   
--   If both <i><tt>sibling</tt></i> and <i><tt>parent</tt></i> are set,
--   then <i><tt>parent</tt></i> must be the parent of
--   <i><tt>sibling</tt></i>. When <i><tt>sibling</tt></i> is set,
--   <i><tt>parent</tt></i> is optional.
--   
--   The <i><tt>iter</tt></i> parameter will be changed to point to this
--   new row. The row will be empty after this function is called. To fill
--   in values, you need to call <tt><i>gtk_tree_store_set()</i></tt> or
--   <a>treeStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreInsertAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

-- | Inserts a new row before <i><tt>sibling</tt></i>.
--   
--   If <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   appended to <i><tt>parent</tt></i>’s children.
--   
--   If <i><tt>parent</tt></i> and <i><tt>sibling</tt></i> are
--   <a>Nothing</a>, then the row will be appended to the toplevel.
--   
--   If both <i><tt>sibling</tt></i> and <i><tt>parent</tt></i> are set,
--   then <i><tt>parent</tt></i> must be the parent of
--   <i><tt>sibling</tt></i>. When <i><tt>sibling</tt></i> is set,
--   <i><tt>parent</tt></i> is optional.
--   
--   The <i><tt>iter</tt></i> parameter will be changed to point to this
--   new row. The row will be empty after this function is called. To fill
--   in values, you need to call <tt><i>gtk_tree_store_set()</i></tt> or
--   <a>treeStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreInsertBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Maybe TreeIter -> m TreeIter

-- | A variant of <tt><i>gtk_tree_store_insert_with_values()</i></tt> which
--   takes the columns and values as two arrays, instead of varargs.
--   
--   This function is mainly intended for language bindings.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreInsertWithValues :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> Int32 -> [Int32] -> [GValue] -> m TreeIter

-- | Checks if <i><tt>iter</tt></i> is an ancestor of
--   <i><tt>descendant</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreIsAncestor :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> TreeIter -> m Bool

-- | Returns the depth of the position pointed by the iterator
--   
--   The depth will be 0 for anything on the root level, 1 for anything
--   down a level, etc.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreIterDepth :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> m Int32

-- | Checks if the given iter is a valid iter for this
--   <tt>GtkTreeStore</tt>.
--   
--   This function is slow. Only use it for debugging and/or testing
--   purposes.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreIterIsValid :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> m Bool

-- | Moves <i><tt>iter</tt></i> in <i><tt>treeStore</tt></i> to the
--   position after <i><tt>position</tt></i>.
--   
--   <i><tt>iter</tt></i> and <i><tt>position</tt></i> should be in the
--   same level.
--   
--   Note that this function only works with unsorted stores.
--   
--   If <i><tt>position</tt></i> is <a>Nothing</a>, <i><tt>iter</tt></i>
--   will be moved to the start of the level.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreMoveAfter :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Moves <i><tt>iter</tt></i> in <i><tt>treeStore</tt></i> to the
--   position before <i><tt>position</tt></i>.
--   
--   <i><tt>iter</tt></i> and <i><tt>position</tt></i> should be in the
--   same level.
--   
--   Note that this function only works with unsorted stores.
--   
--   If <i><tt>position</tt></i> is <a>Nothing</a>, <i><tt>iter</tt></i>
--   will be moved to the end of the level.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreMoveBefore :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Creates a new tree store.
--   
--   This constructor is meant for language bindings.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreNew :: (HasCallStack, MonadIO m) => [GType] -> m TreeStore

-- | Prepends a new row to <i><tt>treeStore</tt></i>.
--   
--   If <i><tt>parent</tt></i> is non-<a>Nothing</a>, then it will prepend
--   the new row before the first child of <i><tt>parent</tt></i>,
--   otherwise it will prepend a row to the top level. The <tt>iter</tt>
--   parameter will be changed to point to this new row. The row will be
--   empty after this function is called. To fill in values, you need to
--   call <tt><i>gtk_tree_store_set()</i></tt> or <a>treeStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStorePrepend :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Removes <i><tt>iter</tt></i> from <i><tt>treeStore</tt></i>.
--   
--   After being removed, <i><tt>iter</tt></i> is set to the next valid row
--   at that level, or invalidated if it previously pointed to the last
--   one.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreRemove :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> m Bool

-- | A variant of <tt><i>gtk_tree_store_set_valist()</i></tt> which takes
--   the columns and values as two arrays, instead of using variadic
--   arguments.
--   
--   This function is mainly intended for language bindings or in case the
--   number of columns to change is not known until run-time.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreSet :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> [Int32] -> [GValue] -> m ()

-- | Sets the type of the columns in a tree store.
--   
--   This function is meant primarily for types that inherit from
--   <tt>GtkTreeStore</tt>, and should only be used when constructing a new
--   <tt>GtkTreeStore</tt>.
--   
--   This functions cannot be called after a row has been added, or a
--   method on the <tt>GtkTreeModel</tt> interface is called on the tree
--   store.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreSetColumnTypes :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> [GType] -> m ()

-- | Sets the data in the cell specified by <i><tt>iter</tt></i> and
--   <i><tt>column</tt></i>.
--   
--   The type of <i><tt>value</tt></i> must be convertible to the type of
--   the column.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreSetValue :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> Int32 -> GValue -> m ()

-- | Swaps <i><tt>a</tt></i> and <i><tt>b</tt></i> in the same level of
--   <i><tt>treeStore</tt></i>.
--   
--   Note that this function only works with unsorted stores.

-- | <i>Deprecated: (Since version 4.10)Use <a>TreeListModel</a>
--   instead</i>
treeStoreSwap :: (HasCallStack, MonadIO m, IsTreeStore a) => a -> TreeIter -> TreeIter -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.TreeStore.TreeStore
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeStore.TreeStore
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeStore.TreeStore
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeStore.TreeStore)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeStore.TreeStore o) => GI.Gtk.Objects.TreeStore.IsTreeStore o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeStore.TreeStore
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeStore.TreeStore


-- | The selection object for GtkTreeView
--   
--   The <tt>GtkTreeSelection</tt> object is a helper object to manage the
--   selection for a <tt>GtkTreeView</tt> widget. The
--   <tt>GtkTreeSelection</tt> object is automatically created when a new
--   <tt>GtkTreeView</tt> widget is created, and cannot exist independently
--   of this widget. The primary reason the <tt>GtkTreeSelection</tt>
--   objects exists is for cleanliness of code and API. That is, there is
--   no conceptual reason all these functions could not be methods on the
--   <tt>GtkTreeView</tt> widget instead of a separate function.
--   
--   The <tt>GtkTreeSelection</tt> object is gotten from a
--   <tt>GtkTreeView</tt> by calling <a>treeViewGetSelection</a>. It can be
--   manipulated to check the selection status of the tree, as well as
--   select and deselect individual rows. Selection is done completely view
--   side. As a result, multiple views of the same model can have
--   completely different selections. Additionally, you cannot change the
--   selection of a row on the model that is not currently displayed by the
--   view without expanding its parents first.
--   
--   One of the important things to remember when monitoring the selection
--   of a view is that the <tt>GtkTreeSelection</tt><a>changed</a> signal
--   is mostly a hint. That is, it may only emit one signal when a range of
--   rows is selected. Additionally, it may on occasion emit a
--   <tt>GtkTreeSelection</tt><a>changed</a> signal when nothing has
--   happened (mostly as a result of programmers calling select_row on an
--   already selected row).
module GI.Gtk.Objects.TreeSelection

-- | Memory-managed wrapper type.
newtype TreeSelection
TreeSelection :: ManagedPtr TreeSelection -> TreeSelection

-- | Type class for types which can be safely cast to <a>TreeSelection</a>,
--   for instance with <a>toTreeSelection</a>.
class (GObject o, IsDescendantOf TreeSelection o) => IsTreeSelection o

-- | Cast to <a>TreeSelection</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeSelection :: (MonadIO m, IsTreeSelection o) => o -> m TreeSelection

-- | Returns the number of rows that have been selected in
--   <i><tt>tree</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionCountSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m Int32

-- | Gets the selection mode for <i><tt>selection</tt></i>. See
--   <a>treeSelectionSetMode</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionGetMode :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m SelectionMode

-- | Sets <i><tt>iter</tt></i> to the currently selected node if
--   <i><tt>selection</tt></i> is set to <a>SelectionModeSingle</a> or
--   <a>SelectionModeBrowse</a>. <i><tt>iter</tt></i> may be NULL if you
--   just want to test if <i><tt>selection</tt></i> has any selected nodes.
--   <i><tt>model</tt></i> is filled with the current model as a
--   convenience. This function will not work if you use
--   <i><tt>selection</tt></i> is <a>SelectionModeMultiple</a>.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionGetSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m (Bool, TreeModel, TreeIter)

-- | Creates a list of path of all selected rows. Additionally, if you are
--   planning on modifying the model after calling this function, you may
--   want to convert the returned list into a list of
--   <tt>GtkTreeRowReference</tt>s. To do this, you can use
--   <a>treeRowReferenceNew</a>.
--   
--   To free the return value, use:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
--   </pre>

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionGetSelectedRows :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ([TreePath], TreeModel)

-- | Returns the tree view associated with <i><tt>selection</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionGetTreeView :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m TreeView

-- | Returns <a>True</a> if the row at <i><tt>iter</tt></i> is currently
--   selected.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionIterIsSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeIter -> m Bool

-- | Returns <a>True</a> if the row pointed to by <i><tt>path</tt></i> is
--   currently selected. If <i><tt>path</tt></i> does not point to a valid
--   location, <a>False</a> is returned

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionPathIsSelected :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m Bool

-- | Selects all the nodes. <i><tt>selection</tt></i> must be set to
--   <a>SelectionModeMultiple</a> mode.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionSelectAll :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ()

-- | Selects the specified iterator.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionSelectIter :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeIter -> m ()

-- | Select the row at <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionSelectPath :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m ()

-- | Selects a range of nodes, determined by <i><tt>startPath</tt></i> and
--   <i><tt>endPath</tt></i> inclusive. <i><tt>selection</tt></i> must be
--   set to <a>SelectionModeMultiple</a> mode.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionSelectRange :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> TreePath -> m ()

-- | Calls a function for each selected node. Note that you cannot modify
--   the tree or selection from within this function. As a result,
--   <a>treeSelectionGetSelectedRows</a> might be more useful.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionSelectedForeach :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeSelectionForeachFunc -> m ()

-- | Sets the selection mode of the <i><tt>selection</tt></i>. If the
--   previous type was <a>SelectionModeMultiple</a>, then the anchor is
--   kept selected, if it was previously selected.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionSetMode :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> SelectionMode -> m ()

-- | Sets the selection function.
--   
--   If set, this function is called before any node is selected or
--   unselected, giving some control over which nodes are selected. The
--   select function should return <a>True</a> if the state of the node may
--   be toggled, and <a>False</a> if the state of the node should be left
--   unchanged.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionSetSelectFunction :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> Maybe TreeSelectionFunc -> m ()

-- | Unselects all the nodes.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionUnselectAll :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> m ()

-- | Unselects the specified iterator.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionUnselectIter :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreeIter -> m ()

-- | Unselects the row at <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionUnselectPath :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> m ()

-- | Unselects a range of nodes, determined by <i><tt>startPath</tt></i>
--   and <i><tt>endPath</tt></i> inclusive.

-- | <i>Deprecated: (Since version 4.10)Use GtkListView or
--   GtkColumnView</i>
treeSelectionUnselectRange :: (HasCallStack, MonadIO m, IsTreeSelection a) => a -> TreePath -> TreePath -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeSelectionMode :: (IsTreeSelection o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeSelection #mode
--   </pre>
getTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> m SelectionMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeSelection [ #mode <a>:=</a> value ]
--   </pre>
setTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> SelectionMode -> m ()

-- | Emitted whenever the selection has (possibly) changed. Please note
--   that this signal is mostly a hint. It may only be emitted once when a
--   range of rows are selected, and it may occasionally be emitted when
--   nothing has happened.
type TreeSelectionChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeSelection #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> ((?self :: a) => TreeSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeSelection #changed callback
--   </pre>
onTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> ((?self :: a) => TreeSelectionChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.TreeSelection.TreeSelection
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeSelection.TreeSelection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeSelection.TreeSelection
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeSelection.TreeSelection)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeSelection.TreeSelection o) => GI.Gtk.Objects.TreeSelection.IsTreeSelection o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeSelection.TreeSelection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeSelection.TreeSelection


-- | A GtkTreeModel which makes an underlying tree model sortable
--   
--   The <tt>GtkTreeModelSort</tt> is a model which implements the
--   <tt>GtkTreeSortable</tt> interface. It does not hold any data itself,
--   but rather is created with a child model and proxies its data. It has
--   identical column types to this child model, and the changes in the
--   child are propagated. The primary purpose of this model is to provide
--   a way to sort a different model without modifying it. Note that the
--   sort function used by <tt>GtkTreeModelSort</tt> is not guaranteed to
--   be stable.
--   
--   The use of this is best demonstrated through an example. In the
--   following sample code we create two <tt>GtkTreeView</tt> widgets each
--   with a view of the same data. As the model is wrapped here by a
--   <tt>GtkTreeModelSort</tt>, the two <tt>GtkTreeView</tt>s can each sort
--   their view of the data without affecting the other. By contrast, if we
--   simply put the same model in each widget, then sorting the first would
--   sort the second.
--   
--   <h2>Using a <tt>GtkTreeModelSort</tt></h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   {
--     GtkTreeView *tree_view1;
--     GtkTreeView *tree_view2;
--     GtkTreeModel *sort_model1;
--     GtkTreeModel *sort_model2;
--     GtkTreeModel *child_model;
--   
--     // get the child model
--     child_model = get_my_model ();
--   
--     // Create the first tree
--     sort_model1 = gtk_tree_model_sort_new_with_model (child_model);
--     tree_view1 = gtk_tree_view_new_with_model (sort_model1);
--   
--     // Create the second tree
--     sort_model2 = gtk_tree_model_sort_new_with_model (child_model);
--     tree_view2 = gtk_tree_view_new_with_model (sort_model2);
--   
--     // Now we can sort the two models independently
--     gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model1),
--                                           COLUMN_1, GTK_SORT_ASCENDING);
--     gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model2),
--                                           COLUMN_1, GTK_SORT_DESCENDING);
--   }
--   </pre>
--   
--   To demonstrate how to access the underlying child model from the sort
--   model, the next example will be a callback for the
--   <tt>GtkTreeSelection</tt> <tt>GtkTreeSelection::changed</tt> signal.
--   In this callback, we get a string from COLUMN_1 of the model. We then
--   modify the string, find the same selected row on the child model, and
--   change the row there.
--   
--   <h2>Accessing the child model of in a selection changed callback</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   void
--   selection_changed (GtkTreeSelection *selection, gpointer data)
--   {
--     GtkTreeModel *sort_model = NULL;
--     GtkTreeModel *child_model;
--     GtkTreeIter sort_iter;
--     GtkTreeIter child_iter;
--     char *some_data = NULL;
--     char *modified_data;
--   
--     // Get the current selected row and the model.
--     if (! gtk_tree_selection_get_selected (selection,
--                                            &amp;sort_model,
--                                            &amp;sort_iter))
--       return;
--   
--     // Look up the current value on the selected row and get
--     // a new value to change it to.
--     gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &amp;sort_iter,
--                         COLUMN_1, &amp;some_data,
--                         -1);
--   
--     modified_data = change_the_data (some_data);
--     g_free (some_data);
--   
--     // Get an iterator on the child model, instead of the sort model.
--     gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sort_model),
--                                                     &amp;child_iter,
--                                                     &amp;sort_iter);
--   
--     // Get the child model and change the value of the row. In this
--     // example, the child model is a GtkListStore. It could be any other
--     // type of model, though.
--     child_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model));
--     gtk_list_store_set (GTK_LIST_STORE (child_model), &amp;child_iter,
--                         COLUMN_1, &amp;modified_data,
--                         -1);
--     g_free (modified_data);
--   }
--   </pre>
module GI.Gtk.Objects.TreeModelSort

-- | Memory-managed wrapper type.
newtype TreeModelSort
TreeModelSort :: ManagedPtr TreeModelSort -> TreeModelSort

-- | Type class for types which can be safely cast to <a>TreeModelSort</a>,
--   for instance with <a>toTreeModelSort</a>.
class (GObject o, IsDescendantOf TreeModelSort o) => IsTreeModelSort o

-- | Cast to <a>TreeModelSort</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeModelSort :: (MonadIO m, IsTreeModelSort o) => o -> m TreeModelSort

-- | This function should almost never be called. It clears the
--   <i><tt>treeModelSort</tt></i> of any cached iterators that haven’t
--   been reffed with <a>treeModelRefNode</a>. This might be useful if the
--   child model being sorted is static (and doesn’t change often) and
--   there has been a lot of unreffed access to nodes. As a side effect of
--   this function, all unreffed iters will be invalid.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelSortClearCache :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m ()

-- | Sets <i><tt>sortIter</tt></i> to point to the row in
--   <i><tt>treeModelSort</tt></i> that corresponds to the row pointed at
--   by <i><tt>childIter</tt></i>. If <i><tt>sortIter</tt></i> was not set,
--   <a>False</a> is returned. Note: a boolean is only returned since 2.14.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelSortConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Converts <i><tt>childPath</tt></i> to a path relative to
--   <i><tt>treeModelSort</tt></i>. That is, <i><tt>childPath</tt></i>
--   points to a path in the child model. The returned path will point to
--   the same row in the sorted model. If <i><tt>childPath</tt></i> isn’t a
--   valid path on the child model, then <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelSortConvertChildPathToPath :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreePath -> m (Maybe TreePath)

-- | Sets <i><tt>childIter</tt></i> to point to the row pointed to by
--   <i><tt>sortedIter</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelSortConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m TreeIter

-- | Converts <i><tt>sortedPath</tt></i> to a path on the child model of
--   <i><tt>treeModelSort</tt></i>. That is, <i><tt>sortedPath</tt></i>
--   points to a location in <i><tt>treeModelSort</tt></i>. The returned
--   path will point to the same location in the model not being sorted. If
--   <i><tt>sortedPath</tt></i> does not point to a location in the child
--   model, <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelSortConvertPathToChildPath :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreePath -> m (Maybe TreePath)

-- | Returns the model the <tt>GtkTreeModelSort</tt> is sorting.
treeModelSortGetModel :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m TreeModel

-- | <pre>
--   This function is slow. Only use it for debugging and\/or testing
--   purposes.
--   </pre>
--   
--   Checks if the given iter is a valid iter for this
--   <tt>GtkTreeModelSort</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelSortIterIsValid :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> TreeIter -> m Bool

-- | Creates a new <tt>GtkTreeModelSort</tt>, with
--   <i><tt>childModel</tt></i> as the child model.
treeModelSortNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m TreeModelSort

-- | This resets the default sort function to be in the “unsorted” state.
--   That is, it is in the same order as the child model. It will re-sort
--   the model to be in the same order as the child model only if the
--   <tt>GtkTreeModelSort</tt> is in “unsorted” state.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelSortResetDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeModelSort a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeModelSortModel :: (IsTreeModelSort o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeModelSort #model
--   </pre>
getTreeModelSortModel :: (MonadIO m, IsTreeModelSort o) => o -> m TreeModel
instance GHC.Classes.Eq GI.Gtk.Objects.TreeModelSort.TreeModelSort
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeModelSort.TreeModelSort
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeModelSort.TreeModelSort
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeModelSort.TreeModelSort)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeModelSort.TreeModelSort o) => GI.Gtk.Objects.TreeModelSort.IsTreeModelSort o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeModelSort.TreeModelSort
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeModelSort.TreeModelSort


-- | A <tt>GtkTreeModel</tt> which hides parts of an underlying tree model
--   
--   A <tt>GtkTreeModelFilter</tt> is a tree model which wraps another tree
--   model, and can do the following things:
--   
--   <ul>
--   <li>Filter specific rows, based on data from a “visible column”, a
--   column storing booleans indicating whether the row should be filtered
--   or not, or based on the return value of a “visible function”, which
--   gets a model, iter and user_data and returns a boolean indicating
--   whether the row should be filtered or not.</li>
--   <li>Modify the “appearance” of the model, using a modify function.
--   This is extremely powerful and allows for just changing some values
--   and also for creating a completely different model based on the given
--   child model.</li>
--   <li>Set a different root node, also known as a “virtual root”. You can
--   pass in a <tt>GtkTreePath</tt> indicating the root node for the filter
--   at construction time.</li>
--   </ul>
--   
--   The basic API is similar to <tt>GtkTreeModelSort</tt>. For an example
--   on its usage, see the section on <tt>GtkTreeModelSort</tt>.
--   
--   When using <tt>GtkTreeModelFilter</tt>, it is important to realize
--   that <tt>GtkTreeModelFilter</tt> maintains an internal cache of all
--   nodes which are visible in its clients. The cache is likely to be a
--   subtree of the tree exposed by the child model.
--   <tt>GtkTreeModelFilter</tt> will not cache the entire child model when
--   unnecessary to not compromise the caching mechanism that is exposed by
--   the reference counting scheme. If the child model implements reference
--   counting, unnecessary signals may not be emitted because of reference
--   counting rule 3, see the <tt>GtkTreeModel</tt> documentation. (Note
--   that e.g. <tt>GtkTreeStore</tt> does not implement reference counting
--   and will always emit all signals, even when the receiving node is not
--   visible).
--   
--   Because of this, limitations for possible visible functions do apply.
--   In general, visible functions should only use data or properties from
--   the node for which the visibility state must be determined, its
--   siblings or its parents. Usually, having a dependency on the state of
--   any child node is not possible, unless references are taken on these
--   explicitly. When no such reference exists, no signals may be received
--   for these child nodes (see reference counting rule number 3 in the
--   <tt>GtkTreeModel</tt> section).
--   
--   Determining the visibility state of a given node based on the state of
--   its child nodes is a frequently occurring use case. Therefore,
--   <tt>GtkTreeModelFilter</tt> explicitly supports this. For example,
--   when a node does not have any children, you might not want the node to
--   be visible. As soon as the first row is added to the node’s child
--   level (or the last row removed), the node’s visibility should be
--   updated.
--   
--   This introduces a dependency from the node on its child nodes. In
--   order to accommodate this, <tt>GtkTreeModelFilter</tt> must make sure
--   the necessary signals are received from the child model. This is
--   achieved by building, for all nodes which are exposed as visible nodes
--   to <tt>GtkTreeModelFilter</tt>'s clients, the child level (if any) and
--   take a reference on the first node in this level. Furthermore, for
--   every row-inserted, row-changed or row-deleted signal (also these
--   which were not handled because the node was not cached),
--   <tt>GtkTreeModelFilter</tt> will check if the visibility state of any
--   parent node has changed.
--   
--   Beware, however, that this explicit support is limited to these two
--   cases. For example, if you want a node to be visible only if two nodes
--   in a child’s child level (2 levels deeper) are visible, you are on
--   your own. In this case, either rely on <tt>GtkTreeStore</tt> to emit
--   all signals because it does not implement reference counting, or for
--   models that do implement reference counting, obtain references on
--   these child levels yourself.
module GI.Gtk.Objects.TreeModelFilter

-- | Memory-managed wrapper type.
newtype TreeModelFilter
TreeModelFilter :: ManagedPtr TreeModelFilter -> TreeModelFilter

-- | Type class for types which can be safely cast to
--   <a>TreeModelFilter</a>, for instance with <a>toTreeModelFilter</a>.
class (GObject o, IsDescendantOf TreeModelFilter o) => IsTreeModelFilter o

-- | Cast to <a>TreeModelFilter</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toTreeModelFilter :: (MonadIO m, IsTreeModelFilter o) => o -> m TreeModelFilter

-- | This function should almost never be called. It clears the
--   <i><tt>filter</tt></i> of any cached iterators that haven’t been
--   reffed with <a>treeModelRefNode</a>. This might be useful if the child
--   model being filtered is static (and doesn’t change often) and there
--   has been a lot of unreffed access to nodes. As a side effect of this
--   function, all unreffed iters will be invalid.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterClearCache :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m ()

-- | Sets <i><tt>filterIter</tt></i> to point to the row in
--   <i><tt>filter</tt></i> that corresponds to the row pointed at by
--   <i><tt>childIter</tt></i>. If <i><tt>filterIter</tt></i> was not set,
--   <a>False</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterConvertChildIterToIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Converts <i><tt>childPath</tt></i> to a path relative to
--   <i><tt>filter</tt></i>. That is, <i><tt>childPath</tt></i> points to a
--   path in the child model. The rerturned path will point to the same row
--   in the filtered model. If <i><tt>childPath</tt></i> isn’t a valid path
--   on the child model or points to a row which is not visible in
--   <i><tt>filter</tt></i>, then <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterConvertChildPathToPath :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreePath -> m (Maybe TreePath)

-- | Sets <i><tt>childIter</tt></i> to point to the row pointed to by
--   <i><tt>filterIter</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterConvertIterToChildIter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeIter -> m TreeIter

-- | Converts <i><tt>filterPath</tt></i> to a path on the child model of
--   <i><tt>filter</tt></i>. That is, <i><tt>filterPath</tt></i> points to
--   a location in <i><tt>filter</tt></i>. The returned path will point to
--   the same location in the model not being filtered. If
--   <i><tt>filterPath</tt></i> does not point to a location in the child
--   model, <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterConvertPathToChildPath :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreePath -> m (Maybe TreePath)

-- | Returns a pointer to the child model of <i><tt>filter</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterGetModel :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m TreeModel

-- | Emits <a>row_changed</a> for each row in the child model, which causes
--   the filter to re-evaluate whether a row is visible or not.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterRefilter :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> m ()

-- | With the <i><tt>nColumns</tt></i> and <i><tt>types</tt></i>
--   parameters, you give an array of column types for this model (which
--   will be exposed to the parent model/view). The <i><tt>func</tt></i>,
--   <i><tt>data</tt></i> and <i><tt>destroy</tt></i> parameters are for
--   specifying the modify function. The modify function will get called
--   for each data access, the goal of the modify function is to return the
--   data which should be displayed at the location specified using the
--   parameters of the modify function.
--   
--   Note that <a>treeModelFilterSetModifyFunc</a> can only be called once
--   for a given filter model.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterSetModifyFunc :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> [GType] -> TreeModelFilterModifyFunc -> m ()

-- | Sets <i><tt>column</tt></i> of the child_model to be the column where
--   <i><tt>filter</tt></i> should look for visibility information.
--   <i><tt>columns</tt></i> should be a column of type
--   <tt><i>G_TYPE_BOOLEAN</i></tt>, where <a>True</a> means that a row is
--   visible, and <a>False</a> if not.
--   
--   Note that <a>treeModelFilterSetVisibleFunc</a> or
--   <a>treeModelFilterSetVisibleColumn</a> can only be called once for a
--   given filter model.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterSetVisibleColumn :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> Int32 -> m ()

-- | Sets the visible function used when filtering the
--   <i><tt>filter</tt></i> to be <i><tt>func</tt></i>. The function should
--   return <a>True</a> if the given row should be visible and <a>False</a>
--   otherwise.
--   
--   If the condition calculated by the function changes over time (e.g.
--   because it depends on some global parameters), you must call
--   <a>treeModelFilterRefilter</a> to keep the visibility information of
--   the model up-to-date.
--   
--   Note that <i><tt>func</tt></i> is called whenever a row is inserted,
--   when it may still be empty. The visible function should therefore take
--   special care of empty rows, like in the example below.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static gboolean
--   visible_func (GtkTreeModel *model,
--                 GtkTreeIter  *iter,
--                 gpointer      data)
--   {
--     // Visible if row is non-empty and first column is “HI”
--     char *str;
--     gboolean visible = FALSE;
--   
--     gtk_tree_model_get (model, iter, 0, &amp;str, -1);
--     if (str &amp;&amp; strcmp (str, "HI") == 0)
--       visible = TRUE;
--     g_free (str);
--   
--     return visible;
--   }
--   </pre>
--   
--   Note that <a>treeModelFilterSetVisibleFunc</a> or
--   <a>treeModelFilterSetVisibleColumn</a> can only be called once for a
--   given filter model.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterSetVisibleFunc :: (HasCallStack, MonadIO m, IsTreeModelFilter a) => a -> TreeModelFilterVisibleFunc -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child-model</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeModelFilterChildModel :: (IsTreeModelFilter o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeModelFilter #childModel
--   </pre>
getTreeModelFilterChildModel :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe TreeModel)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>virtual-root</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeModelFilterVirtualRoot :: (IsTreeModelFilter o, MonadIO m) => TreePath -> m (GValueConstruct o)

-- | Get the value of the “<tt>virtual-root</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeModelFilter #virtualRoot
--   </pre>
getTreeModelFilterVirtualRoot :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe TreePath)
instance GHC.Classes.Eq GI.Gtk.Objects.TreeModelFilter.TreeModelFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeModelFilter.TreeModelFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeModelFilter.TreeModelFilter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeModelFilter.TreeModelFilter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeModelFilter.TreeModelFilter o) => GI.Gtk.Objects.TreeModelFilter.IsTreeModelFilter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeModelFilter.TreeModelFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeModelFilter.TreeModelFilter


-- | A list model that can create child models on demand.
module GI.Gtk.Objects.TreeListModel

-- | Memory-managed wrapper type.
newtype TreeListModel
TreeListModel :: ManagedPtr TreeListModel -> TreeListModel

-- | Type class for types which can be safely cast to <a>TreeListModel</a>,
--   for instance with <a>toTreeListModel</a>.
class (GObject o, IsDescendantOf TreeListModel o) => IsTreeListModel o

-- | Cast to <a>TreeListModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeListModel :: (MonadIO m, IsTreeListModel o) => o -> m TreeListModel

-- | Gets whether the model is set to automatically expand new rows that
--   get added.
--   
--   This can be either rows added by changes to the underlying models or
--   via <a>treeListRowSetExpanded</a>.
treeListModelGetAutoexpand :: (HasCallStack, MonadIO m, IsTreeListModel a) => a -> m Bool

-- | Gets the row item corresponding to the child at index
--   <i><tt>position</tt></i> for <i><tt>self</tt></i>'s root model.
--   
--   If <i><tt>position</tt></i> is greater than the number of children in
--   the root model, <a>Nothing</a> is returned.
--   
--   Do not confuse this function with <a>treeListModelGetRow</a>.
treeListModelGetChildRow :: (HasCallStack, MonadIO m, IsTreeListModel a) => a -> Word32 -> m (Maybe TreeListRow)

-- | Gets the root model that <i><tt>self</tt></i> was created with.
treeListModelGetModel :: (HasCallStack, MonadIO m, IsTreeListModel a) => a -> m ListModel

-- | Gets whether the model is passing through original row items.
--   
--   If this function returns <a>False</a>, the <tt>GListModel</tt>
--   functions for <i><tt>self</tt></i> return custom
--   <tt>GtkTreeListRow</tt> objects. You need to call
--   <a>treeListRowGetItem</a> on these objects to get the original item.
--   
--   If <a>True</a>, the values of the child models are passed through in
--   their original state. You then need to call <a>treeListModelGetRow</a>
--   to get the custom <tt>GtkTreeListRow</tt>s.
treeListModelGetPassthrough :: (HasCallStack, MonadIO m, IsTreeListModel a) => a -> m Bool

-- | Gets the row object for the given row.
--   
--   If <i><tt>position</tt></i> is greater than the number of items in
--   <i><tt>self</tt></i>, <a>Nothing</a> is returned.
--   
--   The row object can be used to expand and collapse rows as well as to
--   inspect its position in the tree. See its documentation for details.
--   
--   This row object is persistent and will refer to the current item as
--   long as the row is present in <i><tt>self</tt></i>, independent of
--   other rows being added or removed.
--   
--   If <i><tt>self</tt></i> is set to not be passthrough, this function is
--   equivalent to calling <tt><i>g_list_model_get_item()</i></tt>.
--   
--   Do not confuse this function with <a>treeListModelGetChildRow</a>.
treeListModelGetRow :: (HasCallStack, MonadIO m, IsTreeListModel a) => a -> Word32 -> m (Maybe TreeListRow)

-- | Creates a new empty <tt>GtkTreeListModel</tt> displaying
--   <i><tt>root</tt></i> with all rows collapsed.
treeListModelNew :: (HasCallStack, MonadIO m, IsListModel a) => a -> Bool -> Bool -> TreeListModelCreateModelFunc -> m TreeListModel

-- | Sets whether the model should autoexpand.
--   
--   If set to <a>True</a>, the model will recursively expand all rows that
--   get added to the model. This can be either rows added by changes to
--   the underlying models or via <a>treeListRowSetExpanded</a>.
treeListModelSetAutoexpand :: (HasCallStack, MonadIO m, IsTreeListModel a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>autoexpand</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeListModelAutoexpand :: (IsTreeListModel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>autoexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListModel #autoexpand
--   </pre>
getTreeListModelAutoexpand :: (MonadIO m, IsTreeListModel o) => o -> m Bool

-- | Set the value of the “<tt>autoexpand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeListModel [ #autoexpand <a>:=</a> value ]
--   </pre>
setTreeListModelAutoexpand :: (MonadIO m, IsTreeListModel o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListModel #itemType
--   </pre>
getTreeListModelItemType :: (MonadIO m, IsTreeListModel o) => o -> m GType

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListModel #model
--   </pre>
getTreeListModelModel :: (MonadIO m, IsTreeListModel o) => o -> m ListModel

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListModel #nItems
--   </pre>
getTreeListModelNItems :: (MonadIO m, IsTreeListModel o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>passthrough</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeListModelPassthrough :: (IsTreeListModel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>passthrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeListModel #passthrough
--   </pre>
getTreeListModelPassthrough :: (MonadIO m, IsTreeListModel o) => o -> m Bool
instance GHC.Classes.Eq GI.Gtk.Objects.TreeListModel.TreeListModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeListModel.TreeListModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeListModel.TreeListModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeListModel.TreeListModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeListModel.TreeListModel o) => GI.Gtk.Objects.TreeListModel.IsTreeListModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeListModel.TreeListModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeListModel.TreeListModel


-- | Provides an expander for a tree-like list.
--   
--   It is typically placed as a bottommost child into a
--   <tt>GtkListView</tt> to allow users to expand and collapse children in
--   a list with a <a>TreeListModel</a>. <tt>GtkTreeExpander</tt> provides
--   the common UI elements, gestures and keybindings for this purpose.
--   
--   On top of this, the "listitem.expand", "listitem.collapse" and
--   "listitem.toggle-expand" actions are provided to allow adding custom
--   UI for managing expanded state.
--   
--   It is important to mention that you want to set the
--   <a>ListItem:focusable</a> property to FALSE when using this widget, as
--   you want the keyboard focus to be in the treexpander, and not inside
--   the list to make use of the keybindings.
--   
--   The <tt>GtkTreeListModel</tt> must be set to not be passthrough. Then
--   it will provide <a>TreeListRow</a> items which can be set via
--   <a>treeExpanderSetListRow</a> on the expander. The expander will then
--   watch that row item automatically. <a>treeExpanderSetChild</a> sets
--   the widget that displays the actual row contents.
--   
--   <tt>GtkTreeExpander</tt> can be modified with properties such as
--   <a>TreeExpander:indentForIcon</a>, <a>TreeExpander:indentForDepth</a>,
--   and <a>TreeExpander:hideExpander</a> to achieve a different
--   appearance. This can even be done to influence individual rows, for
--   example by binding the <a>TreeExpander:hideExpander</a> property to
--   the item count of the model of the treelistrow, to hide the expander
--   for rows without children, even if the row is expandable.
--   
--   <h2>Shortcuts and Gestures</h2>
--   
--   <tt>GtkTreeExpander</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;+&lt;/kbd&gt; or &lt;kbd&gt;*&lt;/kbd&gt; expands the
--   expander.</li>
--   <li>&lt;kbd&gt;-&lt;/kbd&gt; or &lt;kbd&gt;/&lt;/kbd&gt; collapses the
--   expander.</li>
--   <li>Left and right arrow keys, when combined with
--   &lt;kbd&gt;Shift&lt;/kbd&gt; or
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;, will expand
--   or collapse, depending on the locale's text direction.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;␣&lt;/kbd&gt; toggles the
--   expander state.</li>
--   </ul>
--   
--   The row can also expand on drag gestures.
--   
--   <h2>Actions</h2>
--   
--   <tt>GtkTreeExpander</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>listitem.expand</tt> expands the expander if it can be
--   expanded.</li>
--   <li><tt>listitem.collapse</tt> collapses the expander.</li>
--   <li><tt>listitem.toggle-expand</tt> tries to expand the expander if it
--   was collapsed or collapses it if it was expanded.</li>
--   </ul>
--   
--   <h2>CSS nodes</h2>
--   
--   <pre>
--   treeexpander
--   ├── [indent]*
--   ├── [expander]
--   ╰── &lt;child&gt;
--   </pre>
--   
--   <tt>GtkTreeExpander</tt> has zero or one CSS nodes with the name
--   "expander" that should display the expander icon. The node will be
--   <tt>:checked</tt> when it is expanded. If the node is not expandable,
--   an "indent" node will be displayed instead.
--   
--   For every level of depth, another "indent" node is prepended.
--   
--   <h2>Accessibility</h2>
--   
--   Until GTK 4.10, <tt>GtkTreeExpander</tt> used the
--   <a>AccessibleRoleGroup</a> role.
--   
--   Since GTK 4.12, <tt>GtkTreeExpander</tt> uses the
--   <a>AccessibleRoleButton</a> role. Toggling it will change the
--   <tt>GTK_ACCESSIBLE_STATE_EXPANDED</tt> state.
module GI.Gtk.Objects.TreeExpander

-- | Memory-managed wrapper type.
newtype TreeExpander
TreeExpander :: ManagedPtr TreeExpander -> TreeExpander

-- | Type class for types which can be safely cast to <a>TreeExpander</a>,
--   for instance with <a>toTreeExpander</a>.
class (GObject o, IsDescendantOf TreeExpander o) => IsTreeExpander o

-- | Cast to <a>TreeExpander</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeExpander :: (MonadIO m, IsTreeExpander o) => o -> m TreeExpander

-- | Gets the child widget displayed by <i><tt>self</tt></i>.
treeExpanderGetChild :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> m (Maybe Widget)

-- | Gets whether the TreeExpander should be hidden in a GtkTreeListRow.
--   
--   <i>Since: 4.10</i>
treeExpanderGetHideExpander :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> m Bool

-- | TreeExpander indents each level of depth with an additional indent.
--   
--   <i>Since: 4.10</i>
treeExpanderGetIndentForDepth :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> m Bool

-- | TreeExpander indents the child by the width of an expander-icon if it
--   is not expandable.
--   
--   <i>Since: 4.6</i>
treeExpanderGetIndentForIcon :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> m Bool

-- | Forwards the item set on the <tt>GtkTreeListRow</tt> that
--   <i><tt>self</tt></i> is managing.
--   
--   This call is essentially equivalent to calling:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   gtk_tree_list_row_get_item (gtk_tree_expander_get_list_row (@self));
--   </pre>
treeExpanderGetItem :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> m (Maybe Object)

-- | Gets the list row managed by <i><tt>self</tt></i>.
treeExpanderGetListRow :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> m (Maybe TreeListRow)

-- | Creates a new <tt>GtkTreeExpander</tt>
treeExpanderNew :: (HasCallStack, MonadIO m) => m TreeExpander

-- | Sets the content widget to display.
treeExpanderSetChild :: (HasCallStack, MonadIO m, IsTreeExpander a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the expander icon should be visible in a GtkTreeListRow.
--   
--   <i>Since: 4.10</i>
treeExpanderSetHideExpander :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> Bool -> m ()

-- | Sets if the TreeExpander should indent the child according to its
--   depth.
--   
--   <i>Since: 4.10</i>
treeExpanderSetIndentForDepth :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> Bool -> m ()

-- | Sets if the TreeExpander should indent the child by the width of an
--   expander-icon when it is not expandable.
--   
--   <i>Since: 4.6</i>
treeExpanderSetIndentForIcon :: (HasCallStack, MonadIO m, IsTreeExpander a) => a -> Bool -> m ()

-- | Sets the tree list row that this expander should manage.
treeExpanderSetListRow :: (HasCallStack, MonadIO m, IsTreeExpander a, IsTreeListRow b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearTreeExpanderChild :: (MonadIO m, IsTreeExpander o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTreeExpanderChild :: (IsTreeExpander o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeExpander #child
--   </pre>
getTreeExpanderChild :: (MonadIO m, IsTreeExpander o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeExpander [ #child <a>:=</a> value ]
--   </pre>
setTreeExpanderChild :: (MonadIO m, IsTreeExpander o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hide-expander</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTreeExpanderHideExpander :: (IsTreeExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hide-expander</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeExpander #hideExpander
--   </pre>
getTreeExpanderHideExpander :: (MonadIO m, IsTreeExpander o) => o -> m Bool

-- | Set the value of the “<tt>hide-expander</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeExpander [ #hideExpander <a>:=</a> value ]
--   </pre>
setTreeExpanderHideExpander :: (MonadIO m, IsTreeExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent-for-depth</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeExpanderIndentForDepth :: (IsTreeExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>indent-for-depth</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeExpander #indentForDepth
--   </pre>
getTreeExpanderIndentForDepth :: (MonadIO m, IsTreeExpander o) => o -> m Bool

-- | Set the value of the “<tt>indent-for-depth</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeExpander [ #indentForDepth <a>:=</a> value ]
--   </pre>
setTreeExpanderIndentForDepth :: (MonadIO m, IsTreeExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent-for-icon</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTreeExpanderIndentForIcon :: (IsTreeExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>indent-for-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeExpander #indentForIcon
--   </pre>
getTreeExpanderIndentForIcon :: (MonadIO m, IsTreeExpander o) => o -> m Bool

-- | Set the value of the “<tt>indent-for-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeExpander [ #indentForIcon <a>:=</a> value ]
--   </pre>
setTreeExpanderIndentForIcon :: (MonadIO m, IsTreeExpander o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeExpander #item
--   </pre>
getTreeExpanderItem :: (MonadIO m, IsTreeExpander o) => o -> m (Maybe Object)

-- | Set the value of the “<tt>list-row</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #listRow
--   </pre>
clearTreeExpanderListRow :: (MonadIO m, IsTreeExpander o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>list-row</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTreeExpanderListRow :: (IsTreeExpander o, MonadIO m, IsTreeListRow a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>list-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> treeExpander #listRow
--   </pre>
getTreeExpanderListRow :: (MonadIO m, IsTreeExpander o) => o -> m (Maybe TreeListRow)

-- | Set the value of the “<tt>list-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> treeExpander [ #listRow <a>:=</a> value ]
--   </pre>
setTreeExpanderListRow :: (MonadIO m, IsTreeExpander o, IsTreeListRow a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.TreeExpander.TreeExpander
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TreeExpander.TreeExpander
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TreeExpander.TreeExpander
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TreeExpander.TreeExpander)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TreeExpander.TreeExpander o) => GI.Gtk.Objects.TreeExpander.IsTreeExpander o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TreeExpander.TreeExpander
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TreeExpander.TreeExpander


-- | Represents a widget tooltip.
--   
--   Basic tooltips can be realized simply by using
--   <a>widgetSetTooltipText</a> or <a>widgetSetTooltipMarkup</a> without
--   any explicit tooltip object.
--   
--   When you need a tooltip with a little more fancy contents, like adding
--   an image, or you want the tooltip to have different contents per
--   <tt>GtkTreeView</tt> row or cell, you will have to do a little more
--   work:
--   
--   <ul>
--   <li>Set the <a>Widget:hasTooltip</a> property to <a>True</a>. This
--   will make GTK monitor the widget for motion and related events which
--   are needed to determine when and where to show a tooltip.</li>
--   <li>Connect to the <a>Widget::queryTooltip</a> signal. This signal
--   will be emitted when a tooltip is supposed to be shown. One of the
--   arguments passed to the signal handler is a <tt>GtkTooltip</tt>
--   object. This is the object that we are about to display as a tooltip,
--   and can be manipulated in your callback using functions like
--   <a>tooltipSetIcon</a>. There are functions for setting the tooltip’s
--   markup, setting an image from a named icon, or even putting in a
--   custom widget.</li>
--   <li>Return <a>True</a> from your <a>queryTooltip</a> handler. This
--   causes the tooltip to be show. If you return <a>False</a>, it will not
--   be shown.</li>
--   </ul>
module GI.Gtk.Objects.Tooltip

-- | Memory-managed wrapper type.
newtype Tooltip
Tooltip :: ManagedPtr Tooltip -> Tooltip

-- | Type class for types which can be safely cast to <a>Tooltip</a>, for
--   instance with <a>toTooltip</a>.
class (GObject o, IsDescendantOf Tooltip o) => IsTooltip o

-- | Cast to <a>Tooltip</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTooltip :: (MonadIO m, IsTooltip o) => o -> m Tooltip

-- | Replaces the widget packed into the tooltip with
--   <i><tt>customWidget</tt></i>. <i><tt>customWidget</tt></i> does not
--   get destroyed when the tooltip goes away. By default a box with a
--   <tt>GtkImage</tt> and <tt>GtkLabel</tt> is embedded in the tooltip,
--   which can be configured using <a>tooltipSetMarkup</a> and
--   <a>tooltipSetIcon</a>.
tooltipSetCustom :: (HasCallStack, MonadIO m, IsTooltip a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the icon of the tooltip (which is in front of the text) to be
--   <i><tt>paintable</tt></i>. If <i><tt>paintable</tt></i> is
--   <a>Nothing</a>, the image will be hidden.
tooltipSetIcon :: (HasCallStack, MonadIO m, IsTooltip a, IsPaintable b) => a -> Maybe b -> m ()

-- | Sets the icon of the tooltip (which is in front of the text) to be the
--   icon indicated by <i><tt>gicon</tt></i> with the size indicated by
--   <i><tt>size</tt></i>. If <i><tt>gicon</tt></i> is <a>Nothing</a>, the
--   image will be hidden.
tooltipSetIconFromGicon :: (HasCallStack, MonadIO m, IsTooltip a, IsIcon b) => a -> Maybe b -> m ()

-- | Sets the icon of the tooltip (which is in front of the text) to be the
--   icon indicated by <i><tt>iconName</tt></i> with the size indicated by
--   <i><tt>size</tt></i>. If <i><tt>iconName</tt></i> is <a>Nothing</a>,
--   the image will be hidden.
tooltipSetIconFromIconName :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

-- | Sets the text of the tooltip to be <i><tt>markup</tt></i>.
--   
--   The string must be marked up with Pango markup. If
--   <i><tt>markup</tt></i> is <a>Nothing</a>, the label will be hidden.
tooltipSetMarkup :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

-- | Sets the text of the tooltip to be <i><tt>text</tt></i>.
--   
--   If <i><tt>text</tt></i> is <a>Nothing</a>, the label will be hidden.
--   See also <a>tooltipSetMarkup</a>.
tooltipSetText :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Maybe Text -> m ()

-- | Sets the area of the widget, where the contents of this tooltip apply,
--   to be <i><tt>rect</tt></i> (in widget coordinates). This is especially
--   useful for properly setting tooltips on <tt>GtkTreeView</tt> rows and
--   cells, <tt>GtkIconViews</tt>, etc.
--   
--   For setting tooltips on <tt>GtkTreeView</tt>, please refer to the
--   convenience functions for this: <a>treeViewSetTooltipRow</a> and
--   <a>treeViewSetTooltipCell</a>.
tooltipSetTipArea :: (HasCallStack, MonadIO m, IsTooltip a) => a -> Rectangle -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Tooltip.Tooltip
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Tooltip.Tooltip
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Tooltip.Tooltip
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Tooltip.Tooltip)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Tooltip.Tooltip o) => GI.Gtk.Objects.Tooltip.IsTooltip o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Tooltip.Tooltip
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Tooltip.Tooltip


-- | Shows a button which remains “pressed-in” when clicked.
--   
--   &lt;picture&gt; &lt;source srcset="toggle-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Example
--   GtkToggleButtons" src="toggle-button.png"&gt; &lt;/picture&gt;
--   
--   Clicking again will cause the toggle button to return to its normal
--   state.
--   
--   A toggle button is created by calling either <a>toggleButtonNew</a> or
--   <a>toggleButtonNewWithLabel</a>. If using the former, it is advisable
--   to pack a widget, (such as a <tt>GtkLabel</tt> and/or a
--   <tt>GtkImage</tt>), into the toggle button’s container. (See
--   <a>Button</a> for more information).
--   
--   The state of a <tt>GtkToggleButton</tt> can be set specifically using
--   <a>toggleButtonSetActive</a>, and retrieved using
--   <a>toggleButtonGetActive</a>.
--   
--   <h2>Grouping</h2>
--   
--   Toggle buttons can be grouped together, to form mutually exclusive
--   groups - only one of the buttons can be toggled at a time, and
--   toggling another one will switch the currently toggled one off.
--   
--   To add a <tt>GtkToggleButton</tt> to a group, use
--   <a>toggleButtonSetGroup</a>.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkToggleButton</tt> has a single CSS node with name button. To
--   differentiate it from a plain <tt>GtkButton</tt>, it gets the
--   <tt>.toggle</tt> style class.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkToggleButton</tt> uses the <a>AccessibleRoleToggleButton</a>
--   role.
--   
--   <h2>Creating two <tt>GtkToggleButton</tt> widgets.</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   output_state (GtkToggleButton *source,
--                 gpointer         user_data)
--   {
--     g_print ("Toggle button "%s" is active: %s",
--              gtk_button_get_label (GTK_BUTTON (source)),
--              gtk_toggle_button_get_active (source) ? "Yes" : "No");
--   }
--   
--   static void
--   make_toggles (void)
--   {
--     GtkWidget *window, *toggle1, *toggle2;
--     GtkWidget *box;
--     const char *text;
--   
--     window = gtk_window_new ();
--     box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
--   
--     text = "Hi, I’m toggle button one";
--     toggle1 = gtk_toggle_button_new_with_label (text);
--   
--     g_signal_connect (toggle1, "toggled",
--                       G_CALLBACK (output_state),
--                       NULL);
--     gtk_box_append (GTK_BOX (box), toggle1);
--   
--     text = "Hi, I’m toggle button two";
--     toggle2 = gtk_toggle_button_new_with_label (text);
--     g_signal_connect (toggle2, "toggled",
--                       G_CALLBACK (output_state),
--                       NULL);
--     gtk_box_append (GTK_BOX (box), toggle2);
--   
--     gtk_window_set_child (GTK_WINDOW (window), box);
--     gtk_window_present (GTK_WINDOW (window));
--   }
--   </pre>
module GI.Gtk.Objects.ToggleButton

-- | Memory-managed wrapper type.
newtype ToggleButton
ToggleButton :: ManagedPtr ToggleButton -> ToggleButton

-- | Type class for types which can be safely cast to <a>ToggleButton</a>,
--   for instance with <a>toToggleButton</a>.
class (GObject o, IsDescendantOf ToggleButton o) => IsToggleButton o

-- | Cast to <a>ToggleButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toToggleButton :: (MonadIO m, IsToggleButton o) => o -> m ToggleButton

-- | Queries a <tt>GtkToggleButton</tt> and returns its current state.
--   
--   Returns <a>True</a> if the toggle button is pressed in and
--   <a>False</a> if it is raised.
toggleButtonGetActive :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m Bool

-- | Creates a new toggle button.
--   
--   A widget should be packed into the button, as in <a>buttonNew</a>.
toggleButtonNew :: (HasCallStack, MonadIO m) => m ToggleButton

-- | Creates a new toggle button with a text label.
toggleButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m ToggleButton

-- | Creates a new <tt>GtkToggleButton</tt> containing a label.
--   
--   The label will be created using <a>labelNewWithMnemonic</a>, so
--   underscores in <i><tt>label</tt></i> indicate the mnemonic for the
--   button.
toggleButtonNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m ToggleButton

-- | Sets the status of the toggle button.
--   
--   Set to <a>True</a> if you want the <tt>GtkToggleButton</tt> to be
--   “pressed in”, and <a>False</a> to raise it.
--   
--   If the status of the button changes, this action causes the
--   <a>ToggleButton::toggled</a> signal to be emitted.
toggleButtonSetActive :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> Bool -> m ()

-- | Adds <i><tt>self</tt></i> to the group of <i><tt>group</tt></i>.
--   
--   In a group of multiple toggle buttons, only one button can be active
--   at a time.
--   
--   Setting up groups in a cycle leads to undefined behavior.
--   
--   Note that the same effect can be achieved via the <a>Actionable</a>
--   API, by using the same action with parameter type and state type 's'
--   for all buttons in the group, and giving each button its own target
--   value.
toggleButtonSetGroup :: (HasCallStack, MonadIO m, IsToggleButton a, IsToggleButton b) => a -> Maybe b -> m ()

-- | Emits the <a>toggled</a> signal on the <tt>GtkToggleButton</tt>.

-- | <i>Deprecated: (Since version 4.10)There is no good reason for an
--   application ever to call this function.</i>
toggleButtonToggled :: (HasCallStack, MonadIO m, IsToggleButton a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructToggleButtonActive :: (IsToggleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> toggleButton #active
--   </pre>
getToggleButtonActive :: (MonadIO m, IsToggleButton o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleButton [ #active <a>:=</a> value ]
--   </pre>
setToggleButtonActive :: (MonadIO m, IsToggleButton o) => o -> Bool -> m ()

-- | Set the value of the “<tt>group</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #group
--   </pre>
clearToggleButtonGroup :: (MonadIO m, IsToggleButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructToggleButtonGroup :: (IsToggleButton o, MonadIO m, IsToggleButton a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> toggleButton [ #group <a>:=</a> value ]
--   </pre>
setToggleButtonGroup :: (MonadIO m, IsToggleButton o, IsToggleButton a) => o -> a -> m ()

-- | Emitted whenever the <tt>GtkToggleButton</tt>'s state is changed.
type ToggleButtonToggledCallback = IO ()

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> toggleButton #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterToggleButtonToggled :: (IsToggleButton a, MonadIO m) => a -> ((?self :: a) => ToggleButtonToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> toggleButton #toggled callback
--   </pre>
onToggleButtonToggled :: (IsToggleButton a, MonadIO m) => a -> ((?self :: a) => ToggleButtonToggledCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ToggleButton.ToggleButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ToggleButton.ToggleButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ToggleButton.ToggleButton
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ToggleButton.ToggleButton)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ToggleButton.ToggleButton o) => GI.Gtk.Objects.ToggleButton.IsToggleButton o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ToggleButton.ToggleButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ToggleButton.ToggleButton


-- | Displays the contents of a <a>TextBuffer</a>.
--   
--   &lt;picture&gt; &lt;source srcset="multiline-text-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkTextView" src="multiline-text.png"&gt; &lt;/picture&gt;
--   
--   You may wish to begin by reading the <a>conceptual overview</a>, which
--   gives an overview of all the objects and data types related to the
--   text widget and how they work together.
--   
--   <h2>Shortcuts and Gestures</h2>
--   
--   <tt>GtkTextView</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;F10&lt;/kbd&gt; or
--   &lt;kbd&gt;Menu&lt;/kbd&gt; opens the context menu.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Z&lt;/kbd&gt; undoes the
--   last modification.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Y&lt;/kbd&gt; or
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Z&lt;/kbd&gt;
--   redoes the last undone modification.</li>
--   <li>&lt;kbd&gt;Clear&lt;/kbd&gt; clears the content.</li>
--   </ul>
--   
--   Additionally, the following signals have default keybindings:
--   
--   <ul>
--   <li><a>TextView::backspace</a></li>
--   <li><a>TextView::copyClipboard</a></li>
--   <li><a>TextView::cutClipboard</a></li>
--   <li><a>TextView::deleteFromCursor</a></li>
--   <li><a>TextView::insertEmoji</a></li>
--   <li><a>TextView::moveCursor</a></li>
--   <li><a>TextView::pasteClipboard</a></li>
--   <li><a>TextView::selectAll</a></li>
--   <li><a>TextView::toggleCursorVisible</a></li>
--   <li><a>TextView::toggleOverwrite</a></li>
--   </ul>
--   
--   <h2>Actions</h2>
--   
--   <tt>GtkTextView</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>clipboard.copy</tt> copies the contents to the clipboard.</li>
--   <li><tt>clipboard.cut</tt> copies the contents to the clipboard and
--   deletes it from the widget.</li>
--   <li><tt>clipboard.paste</tt> inserts the contents of the clipboard
--   into the widget.</li>
--   <li><tt>menu.popup</tt> opens the context menu.</li>
--   <li><tt>misc.insert-emoji</tt> opens the Emoji chooser.</li>
--   <li><tt>selection.delete</tt> deletes the current selection.</li>
--   <li><tt>selection.select-all</tt> selects all of the widgets
--   content.</li>
--   <li><tt>text.redo</tt> redoes the last change to the contents.</li>
--   <li><tt>text.undo</tt> undoes the last change to the contents.</li>
--   <li><tt>text.clear</tt> clears the content.</li>
--   </ul>
--   
--   <h2>CSS nodes</h2>
--   
--   <pre>
--   textview.view
--   ├── border.top
--   ├── border.left
--   ├── text
--   │   ╰── [selection]
--   ├── border.right
--   ├── border.bottom
--   ╰── [window.popup]
--   </pre>
--   
--   <tt>GtkTextView</tt> has a main css node with name textview and style
--   class .view, and subnodes for each of the border windows, and the main
--   text area, with names border and text, respectively. The border nodes
--   each get one of the style classes .left, .right, .top or .bottom.
--   
--   A node representing the selection will appear below the text node.
--   
--   If a context menu is opened, the window node will appear as a subnode
--   of the main node.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkTextView</tt> uses the <a>AccessibleRoleTextBox</a> role.
module GI.Gtk.Objects.TextView

-- | Memory-managed wrapper type.
newtype TextView
TextView :: ManagedPtr TextView -> TextView

-- | Type class for types which can be safely cast to <a>TextView</a>, for
--   instance with <a>toTextView</a>.
class (GObject o, IsDescendantOf TextView o) => IsTextView o

-- | Cast to <a>TextView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTextView :: (MonadIO m, IsTextView o) => o -> m TextView

-- | Adds a child widget in the text buffer, at the given
--   <i><tt>anchor</tt></i>.
textViewAddChildAtAnchor :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b, IsTextChildAnchor c) => a -> b -> c -> m ()

-- | Adds <i><tt>child</tt></i> at a fixed coordinate in the
--   <tt>GtkTextView</tt>'s text window.
--   
--   The <i><tt>xpos</tt></i> and <i><tt>ypos</tt></i> must be in buffer
--   coordinates (see <a>textViewGetIterLocation</a> to convert to buffer
--   coordinates).
--   
--   <i><tt>child</tt></i> will scroll with the text view.
--   
--   If instead you want a widget that will not move with the
--   <tt>GtkTextView</tt> contents see <tt>GtkOverlay</tt>.
textViewAddOverlay :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Moves the given <i><tt>iter</tt></i> backward by one display (wrapped)
--   line.
--   
--   A display line is different from a paragraph. Paragraphs are separated
--   by newlines or other paragraph separator characters. Display lines are
--   created by line-wrapping a paragraph. If wrapping is turned off,
--   display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <tt>GtkTextBuffer</tt>.
textViewBackwardDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Moves the given <i><tt>iter</tt></i> backward to the next display line
--   start.
--   
--   A display line is different from a paragraph. Paragraphs are separated
--   by newlines or other paragraph separator characters. Display lines are
--   created by line-wrapping a paragraph. If wrapping is turned off,
--   display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <tt>GtkTextBuffer</tt>.
textViewBackwardDisplayLineStart :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Converts buffer coordinates to window coordinates.
textViewBufferToWindowCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

-- | Moves the given <i><tt>iter</tt></i> forward by one display (wrapped)
--   line.
--   
--   A display line is different from a paragraph. Paragraphs are separated
--   by newlines or other paragraph separator characters. Display lines are
--   created by line-wrapping a paragraph. If wrapping is turned off,
--   display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <tt>GtkTextBuffer</tt>.
textViewForwardDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Moves the given <i><tt>iter</tt></i> forward to the next display line
--   end.
--   
--   A display line is different from a paragraph. Paragraphs are separated
--   by newlines or other paragraph separator characters. Display lines are
--   created by line-wrapping a paragraph. If wrapping is turned off,
--   display lines and paragraphs will be the same. Display lines are
--   divided differently for each view, since they depend on the view’s
--   width; paragraphs are the same in all views, since they depend on the
--   contents of the <tt>GtkTextBuffer</tt>.
textViewForwardDisplayLineEnd :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Returns whether pressing the &lt;kbd&gt;Tab&lt;/kbd&gt; key inserts a
--   tab characters.
--   
--   See <a>textViewSetAcceptsTab</a>.
textViewGetAcceptsTab :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the bottom margin for text in the <i><tt>textView</tt></i>.
textViewGetBottomMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Returns the <tt>GtkTextBuffer</tt> being displayed by this text view.
--   
--   The reference count on the buffer is not incremented; the caller of
--   this function won’t own a new reference.
textViewGetBuffer :: (HasCallStack, MonadIO m, IsTextView a) => a -> m TextBuffer

-- | Determine the positions of the strong and weak cursors if the
--   insertion point is at <i><tt>iter</tt></i>.
--   
--   The position of each cursor is stored as a zero-width rectangle. The
--   strong cursor location is the location where characters of the
--   directionality equal to the base direction of the paragraph are
--   inserted. The weak cursor location is the location where characters of
--   the directionality opposite to the base direction of the paragraph are
--   inserted.
--   
--   If <i><tt>iter</tt></i> is <a>Nothing</a>, the actual cursor position
--   is used.
--   
--   Note that if <i><tt>iter</tt></i> happens to be the actual cursor
--   position, and there is currently an IM preedit sequence being entered,
--   the returned locations will be adjusted to account for the preedit
--   cursor’s offset within the preedit sequence.
--   
--   The rectangle position is in buffer coordinates; use
--   <a>textViewBufferToWindowCoords</a> to convert these coordinates to
--   coordinates for one of the windows in the text view.
textViewGetCursorLocations :: (HasCallStack, MonadIO m, IsTextView a) => a -> Maybe TextIter -> m (Rectangle, Rectangle)

-- | Find out whether the cursor should be displayed.
textViewGetCursorVisible :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Returns the default editability of the <tt>GtkTextView</tt>.
--   
--   Tags in the buffer may override this setting for some ranges of text.
textViewGetEditable :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the menu model that gets added to the context menu or
--   <a>Nothing</a> if none has been set.
textViewGetExtraMenu :: (HasCallStack, MonadIO m, IsTextView a) => a -> m (Maybe MenuModel)

-- | Gets a <tt>GtkWidget</tt> that has previously been set as gutter.
--   
--   See <a>textViewSetGutter</a>.
--   
--   <i><tt>win</tt></i> must be one of <a>TextWindowTypeLeft</a>,
--   <a>TextWindowTypeRight</a>, <a>TextWindowTypeTop</a>, or
--   <a>TextWindowTypeBottom</a>.
textViewGetGutter :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> m (Maybe Widget)

-- | Gets the default indentation of paragraphs in
--   <i><tt>textView</tt></i>.
--   
--   Tags in the view’s buffer may override the default. The indentation
--   may be negative.
textViewGetIndent :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the <tt>input-hints</tt> of the <tt>GtkTextView</tt>.
textViewGetInputHints :: (HasCallStack, MonadIO m, IsTextView a) => a -> m [InputHints]

-- | Gets the <tt>input-purpose</tt> of the <tt>GtkTextView</tt>.
textViewGetInputPurpose :: (HasCallStack, MonadIO m, IsTextView a) => a -> m InputPurpose

-- | Retrieves the iterator at buffer coordinates <i><tt>x</tt></i> and
--   <i><tt>y</tt></i>.
--   
--   Buffer coordinates are coordinates for the entire buffer, not just the
--   currently-displayed portion. If you have coordinates from an event,
--   you have to convert those to buffer coordinates with
--   <a>textViewWindowToBufferCoords</a>.
textViewGetIterAtLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter)

-- | Retrieves the iterator pointing to the character at buffer coordinates
--   <i><tt>x</tt></i> and <i><tt>y</tt></i>.
--   
--   Buffer coordinates are coordinates for the entire buffer, not just the
--   currently-displayed portion. If you have coordinates from an event,
--   you have to convert those to buffer coordinates with
--   <a>textViewWindowToBufferCoords</a>.
--   
--   Note that this is different from <a>textViewGetIterAtLocation</a>,
--   which returns cursor locations, i.e. positions between characters.
textViewGetIterAtPosition :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> Int32 -> m (Bool, TextIter, Int32)

-- | Gets a rectangle which roughly contains the character at
--   <i><tt>iter</tt></i>.
--   
--   The rectangle position is in buffer coordinates; use
--   <a>textViewBufferToWindowCoords</a> to convert these coordinates to
--   coordinates for one of the windows in the text view.
textViewGetIterLocation :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Rectangle

-- | Gets the default justification of paragraphs in
--   <i><tt>textView</tt></i>.
--   
--   Tags in the buffer may override the default.
textViewGetJustification :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Justification

-- | Gets the default left margin size of paragraphs in the
--   <i><tt>textView</tt></i>.
--   
--   Tags in the buffer may override the default.
textViewGetLeftMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the <tt>GtkTextIter</tt> at the start of the line containing the
--   coordinate <i><tt>y</tt></i>.
--   
--   <i><tt>y</tt></i> is in buffer coordinates, convert from window
--   coordinates with <a>textViewWindowToBufferCoords</a>. If
--   non-<a>Nothing</a>, <i><tt>lineTop</tt></i> will be filled with the
--   coordinate of the top edge of the line.
textViewGetLineAtY :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m (TextIter, Int32)

-- | Gets the y coordinate of the top of the line containing
--   <i><tt>iter</tt></i>, and the height of the line.
--   
--   The coordinate is a buffer coordinate; convert to window coordinates
--   with <a>textViewBufferToWindowCoords</a>.
textViewGetLineYrange :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m (Int32, Int32)

-- | Gets the <tt>PangoContext</tt> that is used for rendering LTR directed
--   text layouts.
--   
--   The context may be replaced when CSS changes occur.
--   
--   <i>Since: 4.4</i>
textViewGetLtrContext :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Context

-- | Gets whether the <tt>GtkTextView</tt> uses monospace styling.
textViewGetMonospace :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Returns whether the <tt>GtkTextView</tt> is in overwrite mode or not.
textViewGetOverwrite :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Gets the default number of pixels to put above paragraphs.
--   
--   Adding this function with <a>textViewGetPixelsBelowLines</a> is equal
--   to the line space between each paragraph.
textViewGetPixelsAboveLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the default number of pixels to put below paragraphs.
--   
--   The line space is the sum of the value returned by this function and
--   the value returned by <a>textViewGetPixelsAboveLines</a>.
textViewGetPixelsBelowLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the default number of pixels to put between wrapped lines inside
--   a paragraph.
textViewGetPixelsInsideWrap :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the default right margin for text in <i><tt>textView</tt></i>.
--   
--   Tags in the buffer may override the default.
textViewGetRightMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the <tt>PangoContext</tt> that is used for rendering RTL directed
--   text layouts.
--   
--   The context may be replaced when CSS changes occur.
--   
--   <i>Since: 4.4</i>
textViewGetRtlContext :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Context

-- | Gets the default tabs for <i><tt>textView</tt></i>.
--   
--   Tags in the buffer may override the defaults. The returned array will
--   be <a>Nothing</a> if “standard” (8-space) tabs are used. Free the
--   return value with <a>tabArrayFree</a>.
textViewGetTabs :: (HasCallStack, MonadIO m, IsTextView a) => a -> m (Maybe TabArray)

-- | Gets the top margin for text in the <i><tt>textView</tt></i>.
textViewGetTopMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Int32

-- | Gets the X,Y offset in buffer coordinates of the top-left corner of
--   the textview's text contents.
--   
--   This allows for more-precise positioning than what is provided by
--   <a>textViewGetVisibleRect</a> as you can discover what device pixel is
--   being quantized for text positioning.
--   
--   You might want this when making ulterior widgets align with quantized
--   device pixels of the textview contents such as line numbers.
--   
--   <i>Since: 4.18</i>
textViewGetVisibleOffset :: (HasCallStack, MonadIO m, IsTextView a) => a -> m (Double, Double)

-- | Fills <i><tt>visibleRect</tt></i> with the currently-visible region of
--   the buffer, in buffer coordinates.
--   
--   Convert to window coordinates with
--   <a>textViewBufferToWindowCoords</a>.
textViewGetVisibleRect :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Rectangle

-- | Gets the line wrapping for the view.
textViewGetWrapMode :: (HasCallStack, MonadIO m, IsTextView a) => a -> m WrapMode

-- | Allow the <tt>GtkTextView</tt> input method to internally handle key
--   press and release events.
--   
--   If this function returns <a>True</a>, then no further processing
--   should be done for this key event. See <a>iMContextFilterKeypress</a>.
--   
--   Note that you are expected to call this function from your handler
--   when overriding key event handling. This is needed in the case when
--   you need to insert your own key handling between the input method and
--   the default key event handling of the <tt>GtkTextView</tt>.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static gboolean
--   gtk_foo_bar_key_press_event (GtkWidget *widget,
--                                GdkEvent  *event)
--   {
--     guint keyval;
--   
--     gdk_event_get_keyval ((GdkEvent*)event, &amp;keyval);
--   
--     if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
--       {
--         if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
--           return TRUE;
--       }
--   
--     // Do some stuff
--   
--     return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)-&gt;key_press_event (widget, event);
--   }
--   </pre>
textViewImContextFilterKeypress :: (HasCallStack, MonadIO m, IsTextView a, IsEvent b) => a -> b -> m Bool

-- | Moves a mark within the buffer so that it's located within the
--   currently-visible text area.
textViewMoveMarkOnscreen :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> m Bool

-- | Updates the position of a child.
--   
--   See <a>textViewAddOverlay</a>.
textViewMoveOverlay :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()

-- | Move the iterator a given number of characters visually, treating it
--   as the strong cursor position.
--   
--   If <i><tt>count</tt></i> is positive, then the new strong cursor
--   position will be <i><tt>count</tt></i> positions to the right of the
--   old cursor position. If <i><tt>count</tt></i> is negative then the new
--   strong cursor position will be <i><tt>count</tt></i> positions to the
--   left of the old cursor position.
--   
--   In the presence of bi-directional text, the correspondence between
--   logical and visual order will depend on the direction of the current
--   run, and there may be jumps when the cursor is moved off of the end of
--   a run.
textViewMoveVisually :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> Int32 -> m Bool

-- | Creates a new <tt>GtkTextView</tt>.
--   
--   If you don’t call <a>textViewSetBuffer</a> before using the text view,
--   an empty default buffer will be created for you. Get the buffer with
--   <a>textViewGetBuffer</a>. If you want to specify your own buffer,
--   consider <a>textViewNewWithBuffer</a>.
textViewNew :: (HasCallStack, MonadIO m) => m TextView

-- | Creates a new <tt>GtkTextView</tt> widget displaying the buffer
--   <i><tt>buffer</tt></i>.
--   
--   One buffer can be shared among many widgets. <i><tt>buffer</tt></i>
--   may be <a>Nothing</a> to create a default buffer, in which case this
--   function is equivalent to <a>textViewNew</a>. The text view adds its
--   own reference count to the buffer; it does not take over an existing
--   reference.
textViewNewWithBuffer :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextView

-- | Moves the cursor to the currently visible region of the buffer.
textViewPlaceCursorOnscreen :: (HasCallStack, MonadIO m, IsTextView a) => a -> m Bool

-- | Removes a child widget from <i><tt>textView</tt></i>.
textViewRemove :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b) => a -> b -> m ()

-- | Ensures that the cursor is shown.
--   
--   This also resets the time that it will stay blinking (or visible, in
--   case blinking is disabled).
--   
--   This function should be called in response to user input (e.g. from
--   derived classes that override the textview's event handlers).
textViewResetCursorBlink :: (HasCallStack, MonadIO m, IsTextView a) => a -> m ()

-- | Reset the input method context of the text view if needed.
--   
--   This can be necessary in the case where modifying the buffer would
--   confuse on-going input method behavior.
textViewResetImContext :: (HasCallStack, MonadIO m, IsTextView a) => a -> m ()

-- | Scrolls <i><tt>textView</tt></i> the minimum distance such that
--   <i><tt>mark</tt></i> is contained within the visible area of the
--   widget.
textViewScrollMarkOnscreen :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> m ()

-- | Scrolls <i><tt>textView</tt></i> so that <i><tt>iter</tt></i> is on
--   the screen in the position indicated by <i><tt>xalign</tt></i> and
--   <i><tt>yalign</tt></i>.
--   
--   An alignment of 0.0 indicates left or top, 1.0 indicates right or
--   bottom, 0.5 means center. If <i><tt>useAlign</tt></i> is <a>False</a>,
--   the text scrolls the minimal distance to get the mark onscreen,
--   possibly not scrolling at all. The effective screen for purposes of
--   this function is reduced by a margin of size
--   <i><tt>withinMargin</tt></i>.
--   
--   Note that this function uses the currently-computed height of the
--   lines in the text buffer. Line heights are computed in an idle
--   handler; so this function may not have the desired effect if it’s
--   called before the height computations. To avoid oddness, consider
--   using <a>textViewScrollToMark</a> which saves a point to be scrolled
--   to after line validation.
textViewScrollToIter :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> Double -> Bool -> Double -> Double -> m Bool

-- | Scrolls <i><tt>textView</tt></i> so that <i><tt>mark</tt></i> is on
--   the screen in the position indicated by <i><tt>xalign</tt></i> and
--   <i><tt>yalign</tt></i>.
--   
--   An alignment of 0.0 indicates left or top, 1.0 indicates right or
--   bottom, 0.5 means center. If <i><tt>useAlign</tt></i> is <a>False</a>,
--   the text scrolls the minimal distance to get the mark onscreen,
--   possibly not scrolling at all. The effective screen for purposes of
--   this function is reduced by a margin of size
--   <i><tt>withinMargin</tt></i>.
textViewScrollToMark :: (HasCallStack, MonadIO m, IsTextView a, IsTextMark b) => a -> b -> Double -> Bool -> Double -> Double -> m ()

-- | Sets the behavior of the text widget when the
--   &lt;kbd&gt;Tab&lt;/kbd&gt; key is pressed.
--   
--   If <i><tt>acceptsTab</tt></i> is <a>True</a>, a tab character is
--   inserted. If <i><tt>acceptsTab</tt></i> is <a>False</a> the keyboard
--   focus is moved to the next widget in the focus chain.
--   
--   Focus can always be moved using
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt;.
textViewSetAcceptsTab :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the bottom margin for text in <i><tt>textView</tt></i>.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
textViewSetBottomMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets <i><tt>buffer</tt></i> as the buffer being displayed by
--   <i><tt>textView</tt></i>.
--   
--   The previous buffer displayed by the text view is unreferenced, and a
--   reference is added to <i><tt>buffer</tt></i>. If you owned a reference
--   to <i><tt>buffer</tt></i> before passing it to this function, you must
--   remove that reference yourself; <tt>GtkTextView</tt> will not “adopt”
--   it.
textViewSetBuffer :: (HasCallStack, MonadIO m, IsTextView a, IsTextBuffer b) => a -> Maybe b -> m ()

-- | Toggles whether the insertion point should be displayed.
--   
--   A buffer with no editable text probably shouldn’t have a visible
--   cursor, so you may want to turn the cursor off.
--   
--   Note that this property may be overridden by the
--   <a>Settings:gtkKeynavUseCaret</a> setting.
textViewSetCursorVisible :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the default editability of the <tt>GtkTextView</tt>.
--   
--   You can override this default setting with tags in the buffer, using
--   the “editable” attribute of tags.
textViewSetEditable :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets a menu model to add when constructing the context menu for
--   <i><tt>textView</tt></i>.
--   
--   You can pass <a>Nothing</a> to remove a previously set extra menu.
textViewSetExtraMenu :: (HasCallStack, MonadIO m, IsTextView a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Places <i><tt>widget</tt></i> into the gutter specified by
--   <i><tt>win</tt></i>.
--   
--   <i><tt>win</tt></i> must be one of <a>TextWindowTypeLeft</a>,
--   <a>TextWindowTypeRight</a>, <a>TextWindowTypeTop</a>, or
--   <a>TextWindowTypeBottom</a>.
textViewSetGutter :: (HasCallStack, MonadIO m, IsTextView a, IsWidget b) => a -> TextWindowType -> Maybe b -> m ()

-- | Sets the default indentation for paragraphs in
--   <i><tt>textView</tt></i>.
--   
--   Tags in the buffer may override the default.
textViewSetIndent :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the <tt>input-hints</tt> of the <tt>GtkTextView</tt>.
--   
--   The <tt>input-hints</tt> allow input methods to fine-tune their
--   behaviour.
textViewSetInputHints :: (HasCallStack, MonadIO m, IsTextView a) => a -> [InputHints] -> m ()

-- | Sets the <tt>input-purpose</tt> of the <tt>GtkTextView</tt>.
--   
--   The <tt>input-purpose</tt> can be used by on-screen keyboards and
--   other input methods to adjust their behaviour.
textViewSetInputPurpose :: (HasCallStack, MonadIO m, IsTextView a) => a -> InputPurpose -> m ()

-- | Sets the default justification of text in <i><tt>textView</tt></i>.
--   
--   Tags in the view’s buffer may override the default.
textViewSetJustification :: (HasCallStack, MonadIO m, IsTextView a) => a -> Justification -> m ()

-- | Sets the default left margin for text in <i><tt>textView</tt></i>.
--   
--   Tags in the buffer may override the default.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
textViewSetLeftMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets whether the <tt>GtkTextView</tt> should display text in monospace
--   styling.
textViewSetMonospace :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Changes the <tt>GtkTextView</tt> overwrite mode.
textViewSetOverwrite :: (HasCallStack, MonadIO m, IsTextView a) => a -> Bool -> m ()

-- | Sets the default number of blank pixels above paragraphs in
--   <i><tt>textView</tt></i>.
--   
--   Tags in the buffer for <i><tt>textView</tt></i> may override the
--   defaults.
textViewSetPixelsAboveLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default number of pixels of blank space to put below
--   paragraphs in <i><tt>textView</tt></i>.
--   
--   May be overridden by tags applied to <i><tt>textView</tt></i>’s
--   buffer.
textViewSetPixelsBelowLines :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default number of pixels of blank space to leave between
--   display/wrapped lines within a paragraph.
--   
--   May be overridden by tags in <i><tt>textView</tt></i>’s buffer.
textViewSetPixelsInsideWrap :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default right margin for text in the text view.
--   
--   Tags in the buffer may override the default.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
textViewSetRightMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the default tab stops for paragraphs in <i><tt>textView</tt></i>.
--   
--   Tags in the buffer may override the default.
textViewSetTabs :: (HasCallStack, MonadIO m, IsTextView a) => a -> TabArray -> m ()

-- | Sets the top margin for text in <i><tt>textView</tt></i>.
--   
--   Note that this function is confusingly named. In CSS terms, the value
--   set here is padding.
textViewSetTopMargin :: (HasCallStack, MonadIO m, IsTextView a) => a -> Int32 -> m ()

-- | Sets the line wrapping for the view.
textViewSetWrapMode :: (HasCallStack, MonadIO m, IsTextView a) => a -> WrapMode -> m ()

-- | Determines whether <i><tt>iter</tt></i> is at the start of a display
--   line.
--   
--   See <a>textViewForwardDisplayLine</a> for an explanation of display
--   lines vs. paragraphs.
textViewStartsDisplayLine :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextIter -> m Bool

-- | Converts coordinates on the window identified by <i><tt>win</tt></i>
--   to buffer coordinates.
textViewWindowToBufferCoords :: (HasCallStack, MonadIO m, IsTextView a) => a -> TextWindowType -> Int32 -> Int32 -> m (Int32, Int32)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accepts-tab</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewAcceptsTab :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>accepts-tab</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #acceptsTab
--   </pre>
getTextViewAcceptsTab :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>accepts-tab</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #acceptsTab <a>:=</a> value ]
--   </pre>
setTextViewAcceptsTab :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>bottom-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewBottomMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>bottom-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #bottomMargin
--   </pre>
getTextViewBottomMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>bottom-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #bottomMargin <a>:=</a> value ]
--   </pre>
setTextViewBottomMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>buffer</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #buffer
--   </pre>
clearTextViewBuffer :: (MonadIO m, IsTextView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buffer</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextViewBuffer :: (IsTextView o, MonadIO m, IsTextBuffer a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #buffer
--   </pre>
getTextViewBuffer :: (MonadIO m, IsTextView o) => o -> m TextBuffer

-- | Set the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #buffer <a>:=</a> value ]
--   </pre>
setTextViewBuffer :: (MonadIO m, IsTextView o, IsTextBuffer a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cursor-visible</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextViewCursorVisible :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>cursor-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #cursorVisible
--   </pre>
getTextViewCursorVisible :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>cursor-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #cursorVisible <a>:=</a> value ]
--   </pre>
setTextViewCursorVisible :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewEditable :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #editable
--   </pre>
getTextViewEditable :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #editable <a>:=</a> value ]
--   </pre>
setTextViewEditable :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Set the value of the “<tt>extra-menu</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #extraMenu
--   </pre>
clearTextViewExtraMenu :: (MonadIO m, IsTextView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>extra-menu</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewExtraMenu :: (IsTextView o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #extraMenu
--   </pre>
getTextViewExtraMenu :: (MonadIO m, IsTextView o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #extraMenu <a>:=</a> value ]
--   </pre>
setTextViewExtraMenu :: (MonadIO m, IsTextView o, IsMenuModel a) => o -> a -> m ()

-- | Set the value of the “<tt>im-module</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #imModule
--   </pre>
clearTextViewImModule :: (MonadIO m, IsTextView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>im-module</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewImModule :: (IsTextView o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #imModule
--   </pre>
getTextViewImModule :: (MonadIO m, IsTextView o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #imModule <a>:=</a> value ]
--   </pre>
setTextViewImModule :: (MonadIO m, IsTextView o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>indent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextViewIndent :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #indent
--   </pre>
getTextViewIndent :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>indent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #indent <a>:=</a> value ]
--   </pre>
setTextViewIndent :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewInputHints :: (IsTextView o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #inputHints
--   </pre>
getTextViewInputHints :: (MonadIO m, IsTextView o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #inputHints <a>:=</a> value ]
--   </pre>
setTextViewInputHints :: (MonadIO m, IsTextView o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewInputPurpose :: (IsTextView o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #inputPurpose
--   </pre>
getTextViewInputPurpose :: (MonadIO m, IsTextView o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #inputPurpose <a>:=</a> value ]
--   </pre>
setTextViewInputPurpose :: (MonadIO m, IsTextView o) => o -> InputPurpose -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justification</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewJustification :: (IsTextView o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #justification
--   </pre>
getTextViewJustification :: (MonadIO m, IsTextView o) => o -> m Justification

-- | Set the value of the “<tt>justification</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #justification <a>:=</a> value ]
--   </pre>
setTextViewJustification :: (MonadIO m, IsTextView o) => o -> Justification -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewLeftMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #leftMargin
--   </pre>
getTextViewLeftMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>left-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #leftMargin <a>:=</a> value ]
--   </pre>
setTextViewLeftMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>monospace</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewMonospace :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>monospace</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #monospace
--   </pre>
getTextViewMonospace :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>monospace</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #monospace <a>:=</a> value ]
--   </pre>
setTextViewMonospace :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overwrite</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewOverwrite :: (IsTextView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>overwrite</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #overwrite
--   </pre>
getTextViewOverwrite :: (MonadIO m, IsTextView o) => o -> m Bool

-- | Set the value of the “<tt>overwrite</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #overwrite <a>:=</a> value ]
--   </pre>
setTextViewOverwrite :: (MonadIO m, IsTextView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-above-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextViewPixelsAboveLines :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #pixelsAboveLines
--   </pre>
getTextViewPixelsAboveLines :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>pixels-above-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #pixelsAboveLines <a>:=</a> value ]
--   </pre>
setTextViewPixelsAboveLines :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-below-lines</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextViewPixelsBelowLines :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #pixelsBelowLines
--   </pre>
getTextViewPixelsBelowLines :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>pixels-below-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #pixelsBelowLines <a>:=</a> value ]
--   </pre>
setTextViewPixelsBelowLines :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixels-inside-wrap</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextViewPixelsInsideWrap :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #pixelsInsideWrap
--   </pre>
getTextViewPixelsInsideWrap :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>pixels-inside-wrap</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #pixelsInsideWrap <a>:=</a> value ]
--   </pre>
setTextViewPixelsInsideWrap :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>right-margin</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextViewRightMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #rightMargin
--   </pre>
getTextViewRightMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>right-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #rightMargin <a>:=</a> value ]
--   </pre>
setTextViewRightMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextViewTabs :: (IsTextView o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #tabs
--   </pre>
getTextViewTabs :: (MonadIO m, IsTextView o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #tabs <a>:=</a> value ]
--   </pre>
setTextViewTabs :: (MonadIO m, IsTextView o) => o -> TabArray -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>top-margin</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewTopMargin :: (IsTextView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>top-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #topMargin
--   </pre>
getTextViewTopMargin :: (MonadIO m, IsTextView o) => o -> m Int32

-- | Set the value of the “<tt>top-margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #topMargin <a>:=</a> value ]
--   </pre>
setTextViewTopMargin :: (MonadIO m, IsTextView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextViewWrapMode :: (IsTextView o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textView #wrapMode
--   </pre>
getTextViewWrapMode :: (MonadIO m, IsTextView o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textView [ #wrapMode <a>:=</a> value ]
--   </pre>
setTextViewWrapMode :: (MonadIO m, IsTextView o) => o -> WrapMode -> m ()

-- | Gets emitted when the user asks for it.
--   
--   The <a>backspace</a> signal is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Backspace&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Backspace&lt;/kbd&gt;.
type TextViewBackspaceCallback = IO ()

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #backspace callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewBackspace :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #backspace callback
--   </pre>
onTextViewBackspace :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewBackspaceCallback) -> m SignalHandlerId

-- | Gets emitted to copy the selection to the clipboard.
--   
--   The <a>copyClipboard</a> signal is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;c&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Insert&lt;/kbd&gt;.
type TextViewCopyClipboardCallback = IO ()

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #copyClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewCopyClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #copyClipboard callback
--   </pre>
onTextViewCopyClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCopyClipboardCallback) -> m SignalHandlerId

-- | Gets emitted to cut the selection to the clipboard.
--   
--   The <a>cutClipboard</a> signal is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;x&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Delete&lt;/kbd&gt;.
type TextViewCutClipboardCallback = IO ()

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #cutClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewCutClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #cutClipboard callback
--   </pre>
onTextViewCutClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewCutClipboardCallback) -> m SignalHandlerId

-- | Gets emitted when the user initiates a text deletion.
--   
--   The <a>deleteFromCursor</a> signal is a <a>keybinding signal</a>.
--   
--   If the <i><tt>type</tt></i> is <a>DeleteTypeChars</a>, GTK deletes the
--   selection if there is one, otherwise it deletes the requested number
--   of characters.
--   
--   The default bindings for this signal are &lt;kbd&gt;Delete&lt;/kbd&gt;
--   for deleting a character,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Delete&lt;/kbd&gt; for deleting
--   a word and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Backspace&lt;/kbd&gt; for
--   deleting a word backwards.
type TextViewDeleteFromCursorCallback = DeleteType -> Int32 -> IO ()

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #deleteFromCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewDeleteFromCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #deleteFromCursor callback
--   </pre>
onTextViewDeleteFromCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewDeleteFromCursorCallback) -> m SignalHandlerId

-- | Emitted when the selection needs to be extended at
--   <i><tt>location</tt></i>.
type TextViewExtendSelectionCallback = TextExtendSelection -> TextIter -> TextIter -> TextIter -> IO Bool

-- | Connect a signal handler for the <a>extendSelection</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #extendSelection callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewExtendSelection :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewExtendSelectionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>extendSelection</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #extendSelection callback
--   </pre>
onTextViewExtendSelection :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewExtendSelectionCallback) -> m SignalHandlerId

-- | Gets emitted when the user initiates the insertion of a fixed string
--   at the cursor.
--   
--   The <a>insertAtCursor</a> signal is a <a>keybinding signal</a>.
--   
--   This signal has no default bindings.
type TextViewInsertAtCursorCallback = Text -> IO ()

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #insertAtCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewInsertAtCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #insertAtCursor callback
--   </pre>
onTextViewInsertAtCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertAtCursorCallback) -> m SignalHandlerId

-- | Gets emitted to present the Emoji chooser for the
--   <i><tt>textView</tt></i>.
--   
--   The <a>insertEmoji</a> signal is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;.&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;;&lt;/kbd&gt;
type TextViewInsertEmojiCallback = IO ()

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #insertEmoji callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewInsertEmoji :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #insertEmoji callback
--   </pre>
onTextViewInsertEmoji :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewInsertEmojiCallback) -> m SignalHandlerId

-- | Gets emitted when the user initiates a cursor movement.
--   
--   The <a>moveCursor</a> signal is a <a>keybinding signal</a>. If the
--   cursor is not visible in <i><tt>textView</tt></i>, this signal causes
--   the viewport to be moved instead.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the &lt;kbd&gt;Shift&lt;/kbd&gt; modifier extends the selection,
--   the variant without it does not. There are too many key combinations
--   to list them all here.
--   
--   <ul>
--   <li>&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;↑&lt;/kbd&gt;, &lt;kbd&gt;↓&lt;/kbd&gt; move by individual
--   characters/lines</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;, etc. move by
--   words/paragraphs</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt; and &lt;kbd&gt;End&lt;/kbd&gt; move to
--   the ends of the buffer</li>
--   <li>&lt;kbd&gt;PgUp&lt;/kbd&gt; and &lt;kbd&gt;PgDn&lt;/kbd&gt; move
--   vertically by pages</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt; move
--   horizontally by pages</li>
--   </ul>
type TextViewMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewMoveCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #moveCursor callback
--   </pre>
onTextViewMoveCursor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveCursorCallback) -> m SignalHandlerId

-- | Gets emitted to move the viewport.
--   
--   The <a>moveViewport</a> signal is a <a>keybinding signal</a>, which
--   can be bound to key combinations to allow the user to move the
--   viewport, i.e. change what part of the text view is visible in a
--   containing scrolled window.
--   
--   There are no default bindings for this signal.
type TextViewMoveViewportCallback = ScrollStep -> Int32 -> IO ()

-- | Connect a signal handler for the <a>moveViewport</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #moveViewport callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewMoveViewport :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveViewportCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveViewport</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #moveViewport callback
--   </pre>
onTextViewMoveViewport :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewMoveViewportCallback) -> m SignalHandlerId

-- | Gets emitted to paste the contents of the clipboard into the text
--   view.
--   
--   The <a>pasteClipboard</a> signal is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;v&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Insert&lt;/kbd&gt;.
type TextViewPasteClipboardCallback = IO ()

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #pasteClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewPasteClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #pasteClipboard callback
--   </pre>
onTextViewPasteClipboard :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPasteClipboardCallback) -> m SignalHandlerId

-- | Emitted when preedit text of the active IM changes.
--   
--   If an input method is used, the typed text will not immediately be
--   committed to the buffer. So if you are interested in the text, connect
--   to this signal.
--   
--   This signal is only emitted if the text at the given position is
--   actually editable.
type TextViewPreeditChangedCallback = Text -> IO ()

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #preeditChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewPreeditChanged :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #preeditChanged callback
--   </pre>
onTextViewPreeditChanged :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewPreeditChangedCallback) -> m SignalHandlerId

-- | Gets emitted to select or unselect the complete contents of the text
--   view.
--   
--   The <a>selectAll</a> signal is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;a&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;/&lt;/kbd&gt; for selecting and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;a&lt;/kbd&gt;
--   and &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;\&lt;/kbd&gt; for
--   unselecting.
type TextViewSelectAllCallback = Bool -> IO ()

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewSelectAll :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #selectAll callback
--   </pre>
onTextViewSelectAll :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSelectAllCallback) -> m SignalHandlerId

-- | Gets emitted when the user initiates settings the "anchor" mark.
--   
--   The <a>setAnchor</a> signal is a <a>keybinding signal</a> which gets
--   emitted when the user initiates setting the "anchor" mark. The
--   "anchor" mark gets placed at the same position as the "insert" mark.
--   
--   This signal has no default bindings.
type TextViewSetAnchorCallback = IO ()

-- | Connect a signal handler for the <a>setAnchor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textView #setAnchor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewSetAnchor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSetAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>setAnchor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textView #setAnchor callback
--   </pre>
onTextViewSetAnchor :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewSetAnchorCallback) -> m SignalHandlerId

-- | Gets emitted to toggle the <tt>cursor-visible</tt> property.
--   
--   The <a>toggleCursorVisible</a> signal is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;F7&lt;/kbd&gt;.
type TextViewToggleCursorVisibleCallback = IO ()

-- | Connect a signal handler for the <a>toggleCursorVisible</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #toggleCursorVisible callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewToggleCursorVisible :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleCursorVisibleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorVisible</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #toggleCursorVisible callback
--   </pre>
onTextViewToggleCursorVisible :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleCursorVisibleCallback) -> m SignalHandlerId

-- | Gets emitted to toggle the overwrite mode of the text view.
--   
--   The <a>toggleOverwrite</a> signal is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;Insert&lt;/kbd&gt;.
type TextViewToggleOverwriteCallback = IO ()

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textView #toggleOverwrite callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextViewToggleOverwrite :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textView #toggleOverwrite callback
--   </pre>
onTextViewToggleOverwrite :: (IsTextView a, MonadIO m) => a -> ((?self :: a) => TextViewToggleOverwriteCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.TextView.TextView
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TextView.TextView
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TextView.TextView
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TextView.TextView)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TextView.TextView o) => GI.Gtk.Objects.TextView.IsTextView o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TextView.TextView
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TextView.TextView


-- | Collects the tags in a <tt>GtkTextBuffer</tt>.
--   
--   You may wish to begin by reading the <a>text widget conceptual
--   overview</a>, which gives an overview of all the objects and data
--   types related to the text widget and how they work together.
--   
--   <h1>GtkTextTagTables as GtkBuildable</h1>
--   
--   The <tt>GtkTextTagTable</tt> implementation of the
--   <tt>GtkBuildable</tt> interface supports adding tags by specifying
--   “tag” as the “type” attribute of a <tt>&lt;child&gt;</tt> element.
--   
--   An example of a UI definition fragment specifying tags:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkTextTagTable"&gt;
--    &lt;child type="tag"&gt;
--      &lt;object class="GtkTextTag"/&gt;
--    &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
module GI.Gtk.Objects.TextTagTable

-- | Memory-managed wrapper type.
newtype TextTagTable
TextTagTable :: ManagedPtr TextTagTable -> TextTagTable

-- | Type class for types which can be safely cast to <a>TextTagTable</a>,
--   for instance with <a>toTextTagTable</a>.
class (GObject o, IsDescendantOf TextTagTable o) => IsTextTagTable o

-- | Cast to <a>TextTagTable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTextTagTable :: (MonadIO m, IsTextTagTable o) => o -> m TextTagTable

-- | Add a tag to the table.
--   
--   The tag is assigned the highest priority in the table.
--   
--   <i><tt>tag</tt></i> must not be in a tag table already, and may not
--   have the same name as an already-added tag.
textTagTableAdd :: (HasCallStack, MonadIO m, IsTextTagTable a, IsTextTag b) => a -> b -> m Bool

-- | Calls <i><tt>func</tt></i> on each tag in <i><tt>table</tt></i>, with
--   user data <i><tt>data</tt></i>.
--   
--   Note that the table may not be modified while iterating over it (you
--   can’t add/remove tags).
textTagTableForeach :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> TextTagTableForeach -> m ()

-- | Returns the size of the table (number of tags)
textTagTableGetSize :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> m Int32

-- | Look up a named tag.
textTagTableLookup :: (HasCallStack, MonadIO m, IsTextTagTable a) => a -> Text -> m (Maybe TextTag)

-- | Creates a new <tt>GtkTextTagTable</tt>.
--   
--   The table contains no tags by default.
textTagTableNew :: (HasCallStack, MonadIO m) => m TextTagTable

-- | Remove a tag from the table.
--   
--   If a <tt>GtkTextBuffer</tt> has <i><tt>table</tt></i> as its tag
--   table, the tag is removed from the buffer. The table’s reference to
--   the tag is removed, so the tag will end up destroyed if you don’t have
--   a reference to it.
textTagTableRemove :: (HasCallStack, MonadIO m, IsTextTagTable a, IsTextTag b) => a -> b -> m ()

-- | Emitted every time a new tag is added in the <tt>GtkTextTagTable</tt>.
type TextTagTableTagAddedCallback = TextTag -> IO ()

-- | Connect a signal handler for the <a>tagAdded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textTagTable #tagAdded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagAdded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textTagTable #tagAdded callback
--   </pre>
onTextTagTableTagAdded :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagAddedCallback) -> m SignalHandlerId

-- | Emitted every time a tag in the <tt>GtkTextTagTable</tt> changes.
type TextTagTableTagChangedCallback = TextTag -> Bool -> IO ()

-- | Connect a signal handler for the <a>tagChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textTagTable #tagChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textTagTable #tagChanged callback
--   </pre>
onTextTagTableTagChanged :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagChangedCallback) -> m SignalHandlerId

-- | Emitted every time a tag is removed from the <tt>GtkTextTagTable</tt>.
--   
--   The <i><tt>tag</tt></i> is still valid by the time the signal is
--   emitted, but it is not associated with a tag table any more.
type TextTagTableTagRemovedCallback = TextTag -> IO ()

-- | Connect a signal handler for the <a>tagRemoved</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textTagTable #tagRemoved callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>tagRemoved</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textTagTable #tagRemoved callback
--   </pre>
onTextTagTableTagRemoved :: (IsTextTagTable a, MonadIO m) => a -> ((?self :: a) => TextTagTableTagRemovedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.TextTagTable.TextTagTable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TextTagTable.TextTagTable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TextTagTable.TextTagTable
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TextTagTable.TextTagTable)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TextTagTable.TextTagTable o) => GI.Gtk.Objects.TextTagTable.IsTextTagTable o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TextTagTable.TextTagTable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TextTagTable.TextTagTable


-- | Marks a position in a <tt>GtkTextbuffer</tt> that is preserved across
--   modifications.
--   
--   You may wish to begin by reading the <a>text widget conceptual
--   overview</a>, which gives an overview of all the objects and data
--   types related to the text widget and how they work together.
--   
--   A <tt>GtkTextMark</tt> is like a bookmark in a text buffer; it
--   preserves a position in the text. You can convert the mark to an
--   iterator using <a>textBufferGetIterAtMark</a>. Unlike iterators, marks
--   remain valid across buffer mutations, because their behavior is
--   defined when text is inserted or deleted. When text containing a mark
--   is deleted, the mark remains in the position originally occupied by
--   the deleted text. When text is inserted at a mark, a mark with “left
--   gravity” will be moved to the beginning of the newly-inserted text,
--   and a mark with “right gravity” will be moved to the end.
--   
--   Note that “left” and “right” here refer to logical direction (left is
--   the toward the start of the buffer); in some languages such as Hebrew
--   the logically-leftmost text is not actually on the left when
--   displayed.
--   
--   Marks are reference counted, but the reference count only controls the
--   validity of the memory; marks can be deleted from the buffer at any
--   time with <a>textBufferDeleteMark</a>. Once deleted from the buffer, a
--   mark is essentially useless.
--   
--   Marks optionally have names; these can be convenient to avoid passing
--   the <tt>GtkTextMark</tt> object around.
--   
--   Marks are typically created using the <a>textBufferCreateMark</a>
--   function.
module GI.Gtk.Objects.TextMark

-- | Memory-managed wrapper type.
newtype TextMark
TextMark :: ManagedPtr TextMark -> TextMark

-- | Type class for types which can be safely cast to <a>TextMark</a>, for
--   instance with <a>toTextMark</a>.
class (GObject o, IsDescendantOf TextMark o) => IsTextMark o

-- | Cast to <a>TextMark</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTextMark :: (MonadIO m, IsTextMark o) => o -> m TextMark

-- | Gets the buffer this mark is located inside.
--   
--   Returns <a>Nothing</a> if the mark is deleted.
textMarkGetBuffer :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m (Maybe TextBuffer)

-- | Returns <a>True</a> if the mark has been removed from its buffer.
--   
--   See <a>textBufferAddMark</a> for a way to add it to a buffer again.
textMarkGetDeleted :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m Bool

-- | Determines whether the mark has left gravity.
textMarkGetLeftGravity :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m Bool

-- | Returns the mark name.
--   
--   Returns <a>Nothing</a> for anonymous marks.
textMarkGetName :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m (Maybe Text)

-- | Returns <a>True</a> if the mark is visible.
--   
--   A cursor is displayed for visible marks.
textMarkGetVisible :: (HasCallStack, MonadIO m, IsTextMark a) => a -> m Bool

-- | Creates a text mark.
--   
--   Add it to a buffer using <a>textBufferAddMark</a>. If
--   <i><tt>name</tt></i> is <a>Nothing</a>, the mark is anonymous;
--   otherwise, the mark can be retrieved by name using
--   <a>textBufferGetMark</a>. 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
--   (<i><tt>leftGravity</tt></i> = <a>False</a>), 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).
textMarkNew :: (HasCallStack, MonadIO m) => Maybe Text -> Bool -> m TextMark

-- | Sets the visibility of <i><tt>mark</tt></i>.
--   
--   The insertion point is normally visible, i.e. you can see it as a
--   vertical bar. Also, the text widget uses a visible mark to indicate
--   where a drop will occur when dragging-and-dropping text. Most other
--   marks are not visible.
--   
--   Marks are not visible by default.
textMarkSetVisible :: (HasCallStack, MonadIO m, IsTextMark a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>left-gravity</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextMarkLeftGravity :: (IsTextMark o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>left-gravity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textMark #leftGravity
--   </pre>
getTextMarkLeftGravity :: (MonadIO m, IsTextMark o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextMarkName :: (IsTextMark o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textMark #name
--   </pre>
getTextMarkName :: (MonadIO m, IsTextMark o) => o -> m (Maybe Text)
instance GHC.Classes.Eq GI.Gtk.Objects.TextMark.TextMark
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TextMark.TextMark
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TextMark.TextMark
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TextMark.TextMark)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TextMark.TextMark o) => GI.Gtk.Objects.TextMark.IsTextMark o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TextMark.TextMark
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TextMark.TextMark


-- | Marks a spot in a <tt>GtkTextBuffer</tt> where child widgets can be
--   “anchored”.
--   
--   The anchor can have multiple widgets anchored, to allow for multiple
--   views.
module GI.Gtk.Objects.TextChildAnchor

-- | Memory-managed wrapper type.
newtype TextChildAnchor
TextChildAnchor :: ManagedPtr TextChildAnchor -> TextChildAnchor

-- | Type class for types which can be safely cast to
--   <a>TextChildAnchor</a>, for instance with <a>toTextChildAnchor</a>.
class (GObject o, IsDescendantOf TextChildAnchor o) => IsTextChildAnchor o

-- | Cast to <a>TextChildAnchor</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toTextChildAnchor :: (MonadIO m, IsTextChildAnchor o) => o -> m TextChildAnchor

-- | Determines whether a child anchor has been deleted from the buffer.
--   
--   Keep in mind that the child anchor will be unreferenced when removed
--   from the buffer, so you need to hold your own reference (with
--   <a>objectRef</a>) if you plan to use this function — otherwise all
--   deleted child anchors will also be finalized.
textChildAnchorGetDeleted :: (HasCallStack, MonadIO m, IsTextChildAnchor a) => a -> m Bool

-- | Gets a list of all widgets anchored at this child anchor.
--   
--   The order in which the widgets are returned is not defined.
textChildAnchorGetWidgets :: (HasCallStack, MonadIO m, IsTextChildAnchor a) => a -> m [Widget]

-- | Creates a new <tt>GtkTextChildAnchor</tt>.
--   
--   Usually you would then insert it into a <tt>GtkTextBuffer</tt> with
--   <a>textBufferInsertChildAnchor</a>. To perform the creation and
--   insertion in one step, use the convenience function
--   <a>textBufferCreateChildAnchor</a>.
textChildAnchorNew :: (HasCallStack, MonadIO m) => m TextChildAnchor

-- | Creates a new <tt>GtkTextChildAnchor</tt> with the given replacement
--   character.
--   
--   Usually you would then insert it into a <tt>GtkTextBuffer</tt> with
--   <a>textBufferInsertChildAnchor</a>.
--   
--   <i>Since: 4.6</i>
textChildAnchorNewWithReplacement :: (HasCallStack, MonadIO m) => Text -> m TextChildAnchor
instance GHC.Classes.Eq GI.Gtk.Objects.TextChildAnchor.TextChildAnchor
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TextChildAnchor.TextChildAnchor
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TextChildAnchor.TextChildAnchor
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TextChildAnchor.TextChildAnchor)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TextChildAnchor.TextChildAnchor o) => GI.Gtk.Objects.TextChildAnchor.IsTextChildAnchor o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TextChildAnchor.TextChildAnchor
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TextChildAnchor.TextChildAnchor


-- | Stores text and attributes for display in a <tt>GtkTextView</tt>.
--   
--   You may wish to begin by reading the <a>text widget conceptual
--   overview</a>, which gives an overview of all the objects and data
--   types related to the text widget and how they work together.
--   
--   GtkTextBuffer can support undoing changes to the buffer content, see
--   <a>textBufferSetEnableUndo</a>.
module GI.Gtk.Objects.TextBuffer

-- | Memory-managed wrapper type.
newtype TextBuffer
TextBuffer :: ManagedPtr TextBuffer -> TextBuffer

-- | Type class for types which can be safely cast to <a>TextBuffer</a>,
--   for instance with <a>toTextBuffer</a>.
class (GObject o, IsDescendantOf TextBuffer o) => IsTextBuffer o

-- | Cast to <a>TextBuffer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTextBuffer :: (MonadIO m, IsTextBuffer o) => o -> m TextBuffer

-- | Adds a [callback<i><tt>gtk</tt></i>.TextBufferCommitNotify] to be
--   called when a change is to be made to the
--   [type<i><tt>gtk</tt></i>.TextBuffer].
--   
--   Functions are explicitly forbidden from making changes to the
--   [type<i><tt>gtk</tt></i>.TextBuffer] from this callback. It is
--   intended for tracking changes to the buffer only.
--   
--   It may be advantageous to use
--   [callback<i><tt>gtk</tt></i>.TextBufferCommitNotify] over connecting
--   to the <a>TextBuffer::insertText</a> or <a>TextBuffer::deleteRange</a>
--   signals to avoid ordering issues with other signal handlers which may
--   further modify the [type<i><tt>gtk</tt></i>.TextBuffer].
--   
--   <i>Since: 4.16</i>
textBufferAddCommitNotify :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> [TextBufferNotifyFlags] -> TextBufferCommitNotify -> m Word32

-- | Adds the mark at position <i><tt>where</tt></i>.
--   
--   The mark must not be added to another buffer, and if its name is not
--   <a>Nothing</a> then there must not be another mark in the buffer with
--   the same name.
--   
--   Emits the <a>TextBuffer::markSet</a> signal as notification of the
--   mark's initial placement.
textBufferAddMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> TextIter -> m ()

-- | Adds <i><tt>clipboard</tt></i> to the list of clipboards in which the
--   selection contents of <i><tt>buffer</tt></i> are available.
--   
--   In most cases, <i><tt>clipboard</tt></i> will be the
--   <tt>GdkClipboard</tt> returned by <a>widgetGetPrimaryClipboard</a> for
--   a view of <i><tt>buffer</tt></i>.
textBufferAddSelectionClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Emits the “apply-tag” signal on <i><tt>buffer</tt></i>.
--   
--   The default handler for the signal applies <i><tt>tag</tt></i> to the
--   given range. <i><tt>start</tt></i> and <i><tt>end</tt></i> do not have
--   to be in order.
textBufferApplyTag :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextTag b) => a -> b -> TextIter -> TextIter -> m ()

-- | Emits the “apply-tag” signal on <i><tt>buffer</tt></i>.
--   
--   Calls <a>textTagTableLookup</a> on the buffer’s tag table to get a
--   <tt>GtkTextTag</tt>, then calls <a>textBufferApplyTag</a>.
textBufferApplyTagByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> TextIter -> m ()

-- | Performs the appropriate action as if the user hit the delete key with
--   the cursor at the position specified by <i><tt>iter</tt></i>.
--   
--   In the normal case a single character will be deleted, but when
--   combining accents are involved, more than one character can be
--   deleted, and when precomposed character and accent combinations are
--   involved, less than one character will be deleted.
--   
--   Because the buffer is modified, all outstanding iterators become
--   invalid after calling this function; however, the <i><tt>iter</tt></i>
--   will be re-initialized to point to the location where text was
--   deleted.
textBufferBackspace :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Bool -> Bool -> m Bool

-- | Denotes the beginning of an action that may not be undone.
--   
--   This will cause any previous operations in the undo/redo queue to be
--   cleared.
--   
--   This should be paired with a call to
--   <a>textBufferEndIrreversibleAction</a> after the irreversible action
--   has completed.
--   
--   You may nest calls to <a>textBufferBeginIrreversibleAction</a> and
--   <a>textBufferEndIrreversibleAction</a> pairs.
textBufferBeginIrreversibleAction :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Called to indicate that the buffer operations between here and a call
--   to <a>textBufferEndUserAction</a> are part of a single user-visible
--   operation.
--   
--   The operations between <a>textBufferBeginUserAction</a> and
--   <a>textBufferEndUserAction</a> can then be grouped when creating an
--   undo stack. <tt>GtkTextBuffer</tt> maintains a count of calls to
--   <a>textBufferBeginUserAction</a> that have not been closed with a call
--   to <a>textBufferEndUserAction</a>, and emits the “begin-user-action”
--   and “end-user-action” signals only for the outermost pair of calls.
--   This allows you to build user actions from other user actions.
--   
--   The “interactive” buffer mutation functions, such as
--   <a>textBufferInsertInteractive</a>, automatically call begin/end user
--   action around the buffer operations they perform, so there's no need
--   to add extra calls if you user action consists solely of a single call
--   to one of those functions.
textBufferBeginUserAction :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Copies the currently-selected text to a clipboard.
textBufferCopyClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Creates and inserts a child anchor.
--   
--   This is a convenience function which simply creates a child anchor
--   with <a>textChildAnchorNew</a> and inserts it into the buffer with
--   <a>textBufferInsertChildAnchor</a>.
--   
--   The new anchor is owned by the buffer; no reference count is returned
--   to the caller of this function.
textBufferCreateChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> m TextChildAnchor

-- | Creates a mark at position <i><tt>where</tt></i>.
--   
--   If <i><tt>markName</tt></i> is <a>Nothing</a>, the mark is anonymous;
--   otherwise, the mark can be retrieved by name using
--   <a>textBufferGetMark</a>. 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
--   (<i><tt>leftGravity</tt></i> = <a>False</a>), 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).
--   
--   The caller of this function does not own a reference to the returned
--   <tt>GtkTextMark</tt>, so you can ignore the return value if you like.
--   Marks are owned by the buffer and go away when the buffer does.
--   
--   Emits the <a>TextBuffer::markSet</a> signal as notification of the
--   mark's initial placement.
textBufferCreateMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Maybe Text -> TextIter -> Bool -> m TextMark

-- | Copies the currently-selected text to a clipboard, then deletes said
--   text if it’s editable.
textBufferCutClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> Bool -> m ()

-- | Deletes text between <i><tt>start</tt></i> and <i><tt>end</tt></i>.
--   
--   The order of <i><tt>start</tt></i> and <i><tt>end</tt></i> is not
--   actually relevant; <a>textBufferDelete</a> will reorder them.
--   
--   This function actually emits the “delete-range” signal, and the
--   default handler of that signal deletes the text. Because the buffer is
--   modified, all outstanding iterators become invalid after calling this
--   function; however, the <i><tt>start</tt></i> and <i><tt>end</tt></i>
--   will be re-initialized to point to the location where text was
--   deleted.
textBufferDelete :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Deletes all editable text in the given range.
--   
--   Calls <a>textBufferDelete</a> for each editable sub-range of
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>). <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> are revalidated to point to the location of the
--   last deleted range, or left untouched if no text was deleted.
textBufferDeleteInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> Bool -> m Bool

-- | Deletes <i><tt>mark</tt></i>, so that it’s no longer located anywhere
--   in the buffer.
--   
--   Removes the reference the buffer holds to the mark, so if you haven’t
--   called <a>objectRef</a> on the mark, it will be freed. Even if the
--   mark isn’t freed, most operations on <i><tt>mark</tt></i> become
--   invalid, until it gets added to a buffer again with
--   <a>textBufferAddMark</a>. Use <a>textMarkGetDeleted</a> to find out if
--   a mark has been removed from its buffer.
--   
--   The <a>TextBuffer::markDeleted</a> signal will be emitted as
--   notification after the mark is deleted.
textBufferDeleteMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> m ()

-- | Deletes the mark named <i><tt>name</tt></i>; the mark must exist.
--   
--   See <a>textBufferDeleteMark</a> for details.
textBufferDeleteMarkByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> m ()

-- | Deletes the range between the “insert” and “selection_bound” marks,
--   that is, the currently-selected text.
--   
--   If <i><tt>interactive</tt></i> is <a>True</a>, the editability of the
--   selection will be considered (users can’t delete uneditable text).
textBufferDeleteSelection :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Bool -> Bool -> m Bool

-- | Denotes the end of an action that may not be undone.
--   
--   This will cause any previous operations in the undo/redo queue to be
--   cleared.
--   
--   This should be called after completing modifications to the text
--   buffer after <a>textBufferBeginIrreversibleAction</a> was called.
--   
--   You may nest calls to <a>textBufferBeginIrreversibleAction</a> and
--   <a>textBufferEndIrreversibleAction</a> pairs.
textBufferEndIrreversibleAction :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Ends a user-visible operation.
--   
--   Should be paired with a call to <a>textBufferBeginUserAction</a>. See
--   that function for a full explanation.
textBufferEndUserAction :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Retrieves the first and last iterators in the buffer, i.e. the entire
--   buffer lies within the range
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>).
textBufferGetBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (TextIter, TextIter)

-- | Gets whether there is a redoable action in the history.
textBufferGetCanRedo :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Gets whether there is an undoable action in the history.
textBufferGetCanUndo :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Gets the number of characters in the buffer.
--   
--   Note that characters and bytes are not the same, you can’t e.g. expect
--   the contents of the buffer in string form to be this many bytes long.
--   
--   The character count is cached, so this function is very fast.
textBufferGetCharCount :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Int32

-- | Gets whether the buffer is saving modifications to the buffer to allow
--   for undo and redo actions.
--   
--   See <a>textBufferBeginIrreversibleAction</a> and
--   <a>textBufferEndIrreversibleAction</a> to create changes to the buffer
--   that cannot be undone.
textBufferGetEnableUndo :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Initializes <i><tt>iter</tt></i> with the “end iterator,” one past the
--   last valid character in the text buffer.
--   
--   If dereferenced with <a>textIterGetChar</a>, the end iterator has a
--   character value of 0. The entire buffer lies in the range from the
--   first position in the buffer (call <a>textBufferGetStartIter</a> to
--   get character position 0) to the end iterator.
textBufferGetEndIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextIter

-- | Indicates whether the buffer has some text currently selected.
textBufferGetHasSelection :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Returns the mark that represents the cursor (insertion point).
--   
--   Equivalent to calling <a>textBufferGetMark</a> to get the mark named
--   “insert”, but very slightly more efficient, and involves less typing.
textBufferGetInsert :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextMark

-- | Obtains the location of <i><tt>anchor</tt></i> within
--   <i><tt>buffer</tt></i>.
textBufferGetIterAtChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextChildAnchor b) => a -> b -> m TextIter

-- | Initializes <i><tt>iter</tt></i> to the start of the given line.
--   
--   If <i><tt>lineNumber</tt></i> is greater than or equal to the number
--   of lines in the <i><tt>buffer</tt></i>, the end iterator is returned.
textBufferGetIterAtLine :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m (Bool, TextIter)

-- | Obtains an iterator pointing to <i><tt>byteIndex</tt></i> within the
--   given line.
--   
--   <i><tt>byteIndex</tt></i> must be the start of a UTF-8 character. Note
--   bytes, not characters; UTF-8 may encode one character as multiple
--   bytes.
--   
--   If <i><tt>lineNumber</tt></i> is greater than or equal to the number
--   of lines in the <i><tt>buffer</tt></i>, the end iterator is returned.
--   And if <i><tt>byteIndex</tt></i> is off the end of the line, the
--   iterator at the end of the line is returned.
textBufferGetIterAtLineIndex :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m (Bool, TextIter)

-- | Obtains an iterator pointing to <i><tt>charOffset</tt></i> within the
--   given line.
--   
--   Note characters, not bytes; UTF-8 may encode one character as multiple
--   bytes.
--   
--   If <i><tt>lineNumber</tt></i> is greater than or equal to the number
--   of lines in the <i><tt>buffer</tt></i>, the end iterator is returned.
--   And if <i><tt>charOffset</tt></i> is off the end of the line, the
--   iterator at the end of the line is returned.
textBufferGetIterAtLineOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> Int32 -> m (Bool, TextIter)

-- | Initializes <i><tt>iter</tt></i> with the current position of
--   <i><tt>mark</tt></i>.
textBufferGetIterAtMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> m TextIter

-- | Initializes <i><tt>iter</tt></i> to a position
--   <i><tt>charOffset</tt></i> chars from the start of the entire buffer.
--   
--   If <i><tt>charOffset</tt></i> is -1 or greater than the number of
--   characters in the buffer, <i><tt>iter</tt></i> is initialized to the
--   end iterator, the iterator one past the last valid character in the
--   buffer.
textBufferGetIterAtOffset :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Int32 -> m TextIter

-- | Obtains the number of lines in the buffer.
--   
--   This value is cached, so the function is very fast.
textBufferGetLineCount :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Int32

-- | Returns the mark named <i><tt>name</tt></i> in buffer
--   <i><tt>buffer</tt></i>, or <a>Nothing</a> if no such mark exists in
--   the buffer.
textBufferGetMark :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> m (Maybe TextMark)

-- | Gets the maximum number of undo levels to perform.
--   
--   If 0, unlimited undo actions may be performed. Note that this may have
--   a memory usage impact as it requires storing an additional copy of the
--   inserted or removed text within the text buffer.
textBufferGetMaxUndoLevels :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Word32

-- | Indicates whether the buffer has been modified since the last call to
--   <a>textBufferSetModified</a> set the modification flag to
--   <a>False</a>.
--   
--   Used for example to enable a “save” function in a text editor.
textBufferGetModified :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m Bool

-- | Returns the mark that represents the selection bound.
--   
--   Equivalent to calling <a>textBufferGetMark</a> to get the mark named
--   “selection_bound”, but very slightly more efficient, and involves less
--   typing.
--   
--   The currently-selected text in <i><tt>buffer</tt></i> is the region
--   between the “selection_bound” and “insert” marks. If “selection_bound”
--   and “insert” are in the same place, then there is no current
--   selection. <a>textBufferGetSelectionBounds</a> is another convenient
--   function for handling the selection, if you just want to know whether
--   there’s a selection and what its bounds are.
textBufferGetSelectionBound :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextMark

-- | Returns <a>True</a> if some text is selected; places the bounds of the
--   selection in <i><tt>start</tt></i> and <i><tt>end</tt></i>.
--   
--   If the selection has length 0, then <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> are filled in with the same value.
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> will be in ascending
--   order. If <i><tt>start</tt></i> and <i><tt>end</tt></i> are
--   <a>Nothing</a>, then they are not filled in, but the return value
--   still indicates whether text is selected.
textBufferGetSelectionBounds :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m (Bool, TextIter, TextIter)

-- | Get a content provider for this buffer.
--   
--   It can be used to make the content of <i><tt>buffer</tt></i> available
--   in a <tt>GdkClipboard</tt>, see <a>clipboardSetContent</a>.
textBufferGetSelectionContent :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ContentProvider

-- | Returns the text in the range
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>).
--   
--   Excludes undisplayed text (text marked with tags that set the
--   invisibility attribute) if <i><tt>includeHiddenChars</tt></i> is
--   <a>False</a>. The returned string includes a 0xFFFC character whenever
--   the buffer contains embedded images, so byte and character indexes
--   into the returned string do correspond to byte and character indexes
--   into the buffer. Contrast with <a>textBufferGetText</a>. Note that
--   0xFFFC can occur in normal text as well, so it is not a reliable
--   indicator that a paintable or widget is in the buffer.
textBufferGetSlice :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> Bool -> m Text

-- | Initialized <i><tt>iter</tt></i> with the first position in the text
--   buffer.
--   
--   This is the same as using <a>textBufferGetIterAtOffset</a> to get the
--   iter at character offset 0.
textBufferGetStartIter :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextIter

-- | Get the <tt>GtkTextTagTable</tt> associated with this buffer.
textBufferGetTagTable :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m TextTagTable

-- | Returns the text in the range
--   [<i><tt>start</tt></i>,<i><tt>end</tt></i>).
--   
--   Excludes undisplayed text (text marked with tags that set the
--   invisibility attribute) if <i><tt>includeHiddenChars</tt></i> is
--   <a>False</a>. Does not include characters representing embedded
--   images, so byte and character indexes into the returned string do not
--   correspond to byte and character indexes into the buffer. Contrast
--   with <a>textBufferGetSlice</a>.
textBufferGetText :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> Bool -> m Text

-- | Inserts <i><tt>len</tt></i> bytes of <i><tt>text</tt></i> at position
--   <i><tt>iter</tt></i>.
--   
--   If <i><tt>len</tt></i> is -1, <i><tt>text</tt></i> must be
--   nul-terminated and will be inserted in its entirety. Emits the
--   “insert-text” signal; insertion actually occurs in the default handler
--   for the signal. <i><tt>iter</tt></i> is invalidated when insertion
--   occurs (because the buffer contents change), but the default signal
--   handler revalidates it to point to the end of the inserted text.
textBufferInsert :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> m ()

-- | Inserts <i><tt>text</tt></i> in <i><tt>buffer</tt></i>.
--   
--   Simply calls <a>textBufferInsert</a>, using the current cursor
--   position as the insertion point.
textBufferInsertAtCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> m ()

-- | Inserts a child widget anchor into the text buffer at
--   <i><tt>iter</tt></i>.
--   
--   The anchor will be counted as one character in character counts, and
--   when obtaining the buffer contents as a string, will be represented by
--   the Unicode “object replacement character” 0xFFFC. Note that the
--   “slice” variants for obtaining portions of the buffer as a string
--   include this character for child anchors, but the “text” variants do
--   not. E.g. see <a>textBufferGetSlice</a> and <a>textBufferGetText</a>.
--   
--   Consider <a>textBufferCreateChildAnchor</a> as a more convenient
--   alternative to this function. The buffer will add a reference to the
--   anchor, so you can unref it after insertion.
textBufferInsertChildAnchor :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextChildAnchor b) => a -> TextIter -> b -> m ()

-- | Inserts <i><tt>text</tt></i> in <i><tt>buffer</tt></i>.
--   
--   Like <a>textBufferInsert</a>, but the insertion will not occur if
--   <i><tt>iter</tt></i> is at a non-editable location in the buffer.
--   Usually you want to prevent insertions at ineditable locations if the
--   insertion results from a user action (is interactive).
--   
--   <i><tt>defaultEditable</tt></i> indicates the editability of text that
--   doesn't have a tag affecting editability applied to it. Typically the
--   result of <a>textViewGetEditable</a> is appropriate here.
textBufferInsertInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> Bool -> m Bool

-- | Inserts <i><tt>text</tt></i> in <i><tt>buffer</tt></i>.
--   
--   Calls <a>textBufferInsertInteractive</a> at the cursor position.
--   
--   <i><tt>defaultEditable</tt></i> indicates the editability of text that
--   doesn't have a tag affecting editability applied to it. Typically the
--   result of <a>textViewGetEditable</a> is appropriate here.
textBufferInsertInteractiveAtCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> Bool -> m Bool

-- | Inserts the text in <i><tt>markup</tt></i> at position
--   <i><tt>iter</tt></i>.
--   
--   <i><tt>markup</tt></i> will be inserted in its entirety and must be
--   nul-terminated and valid UTF-8. Emits the
--   <a>TextBuffer::insertText</a> signal, possibly multiple times;
--   insertion actually occurs in the default handler for the signal.
--   <i><tt>iter</tt></i> will point to the end of the inserted text on
--   return.
textBufferInsertMarkup :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> Text -> Int32 -> m ()

-- | Inserts an image into the text buffer at <i><tt>iter</tt></i>.
--   
--   The image will be counted as one character in character counts, and
--   when obtaining the buffer contents as a string, will be represented by
--   the Unicode “object replacement character” 0xFFFC. Note that the
--   “slice” variants for obtaining portions of the buffer as a string
--   include this character for paintable, but the “text” variants do not.
--   e.g. see <a>textBufferGetSlice</a> and <a>textBufferGetText</a>.
textBufferInsertPaintable :: (HasCallStack, MonadIO m, IsTextBuffer a, IsPaintable b) => a -> TextIter -> b -> m ()

-- | Copies text, tags, and paintables between <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> and inserts the copy at <i><tt>iter</tt></i>.
--   
--   The order of <i><tt>start</tt></i> and <i><tt>end</tt></i> doesn’t
--   matter.
--   
--   Used instead of simply getting/inserting text because it preserves
--   images and tags. If <i><tt>start</tt></i> and <i><tt>end</tt></i> are
--   in a different buffer from <i><tt>buffer</tt></i>, the two buffers
--   must share the same tag table.
--   
--   Implemented via emissions of the <a>insertText</a> and <a>applyTag</a>
--   signals, so expect those.
textBufferInsertRange :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> TextIter -> m ()

-- | Copies text, tags, and paintables between <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> and inserts the copy at <i><tt>iter</tt></i>.
--   
--   Same as <a>textBufferInsertRange</a>, but does nothing if the
--   insertion point isn’t editable. The <i><tt>defaultEditable</tt></i>
--   parameter indicates whether the text is editable at
--   <i><tt>iter</tt></i> if no tags enclosing <i><tt>iter</tt></i> affect
--   editability. Typically the result of <a>textViewGetEditable</a> is
--   appropriate here.
textBufferInsertRangeInteractive :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> TextIter -> Bool -> m Bool

-- | Moves <i><tt>mark</tt></i> to the new location <i><tt>where</tt></i>.
--   
--   Emits the <a>TextBuffer::markSet</a> signal as notification of the
--   move.
textBufferMoveMark :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextMark b) => a -> b -> TextIter -> m ()

-- | Moves the mark named <i><tt>name</tt></i> (which must exist) to
--   location <i><tt>where</tt></i>.
--   
--   See <a>textBufferMoveMark</a> for details.
textBufferMoveMarkByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> m ()

-- | Creates a new text buffer.
textBufferNew :: (HasCallStack, MonadIO m, IsTextTagTable a) => Maybe a -> m TextBuffer

-- | Pastes the contents of a clipboard.
--   
--   If <i><tt>overrideLocation</tt></i> is <a>Nothing</a>, the pasted text
--   will be inserted at the cursor position, or the buffer selection will
--   be replaced if the selection is non-empty.
--   
--   Note: pasting is asynchronous, that is, we’ll ask for the paste data
--   and return, and at some point later after the main loop runs, the
--   paste data will be inserted.
textBufferPasteClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> Maybe TextIter -> Bool -> m ()

-- | This function moves the “insert” and “selection_bound” marks
--   simultaneously.
--   
--   If you move them to the same place in two steps with
--   <a>textBufferMoveMark</a>, you will temporarily select a region in
--   between their old and new locations, which can be pretty inefficient
--   since the temporarily-selected region will force stuff to be
--   recalculated. This function moves them as a unit, which can be
--   optimized.
textBufferPlaceCursor :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> m ()

-- | Redoes the next redoable action on the buffer, if there is one.
textBufferRedo :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Removes all tags in the range between <i><tt>start</tt></i> and
--   <i><tt>end</tt></i>.
--   
--   Be careful with this function; it could remove tags added in code
--   unrelated to the code you’re currently writing. That is, using this
--   function is probably a bad idea if you have two or more unrelated code
--   sections that add tags.
textBufferRemoveAllTags :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Removes the <tt>GtkTextBufferCommitNotify</tt> handler previously
--   registered with <a>textBufferAddCommitNotify</a>.
--   
--   This may result in the <tt>user_data_destroy</tt> being called that
--   was passed when registering the commit notify functions.
--   
--   <i>Since: 4.16</i>
textBufferRemoveCommitNotify :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Word32 -> m ()

-- | Removes a <tt>GdkClipboard</tt> added with
--   <a>textBufferAddSelectionClipboard</a>
textBufferRemoveSelectionClipboard :: (HasCallStack, MonadIO m, IsTextBuffer a, IsClipboard b) => a -> b -> m ()

-- | Emits the “remove-tag” signal.
--   
--   The default handler for the signal removes all occurrences of
--   <i><tt>tag</tt></i> from the given range. <i><tt>start</tt></i> and
--   <i><tt>end</tt></i> don’t have to be in order.
textBufferRemoveTag :: (HasCallStack, MonadIO m, IsTextBuffer a, IsTextTag b) => a -> b -> TextIter -> TextIter -> m ()

-- | Emits the “remove-tag” signal.
--   
--   Calls <a>textTagTableLookup</a> on the buffer’s tag table to get a
--   <tt>GtkTextTag</tt>, then calls <a>textBufferRemoveTag</a>.
textBufferRemoveTagByName :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> TextIter -> TextIter -> m ()

-- | This function moves the “insert” and “selection_bound” marks
--   simultaneously.
--   
--   If you move them in two steps with <a>textBufferMoveMark</a>, you will
--   temporarily select a region in between their old and new locations,
--   which can be pretty inefficient since the temporarily-selected region
--   will force stuff to be recalculated. This function moves them as a
--   unit, which can be optimized.
textBufferSelectRange :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> TextIter -> TextIter -> m ()

-- | Sets whether or not to enable undoable actions in the text buffer.
--   
--   Undoable actions in this context are changes to the text content of
--   the buffer. Changes to tags and marks are not tracked.
--   
--   If enabled, the user will be able to undo the last number of actions
--   up to <a>textBufferGetMaxUndoLevels</a>.
--   
--   See <a>textBufferBeginIrreversibleAction</a> and
--   <a>textBufferEndIrreversibleAction</a> to create changes to the buffer
--   that cannot be undone.
textBufferSetEnableUndo :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Bool -> m ()

-- | Sets the maximum number of undo levels to perform.
--   
--   If 0, unlimited undo actions may be performed. Note that this may have
--   a memory usage impact as it requires storing an additional copy of the
--   inserted or removed text within the text buffer.
textBufferSetMaxUndoLevels :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Word32 -> m ()

-- | Used to keep track of whether the buffer has been modified since the
--   last time it was saved.
--   
--   Whenever the buffer is saved to disk, call
--   <tt>gtk_text_buffer_set_modified (@buffer, FALSE)</tt>. When the
--   buffer is modified, it will automatically toggle on the modified bit
--   again. When the modified bit flips, the buffer emits the
--   <a>TextBuffer::modifiedChanged</a> signal.
textBufferSetModified :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Bool -> m ()

-- | Deletes current contents of <i><tt>buffer</tt></i>, and inserts
--   <i><tt>text</tt></i> instead. This is automatically marked as an
--   irreversible action in the undo stack. If you wish to mark this action
--   as part of a larger undo operation, call
--   [method<i><tt>textBuffer</tt></i>.delete] and
--   [method<i><tt>textBuffer</tt></i>.insert] directly instead.
--   
--   If <i><tt>len</tt></i> is -1, <i><tt>text</tt></i> must be
--   nul-terminated. <i><tt>text</tt></i> must be valid UTF-8.
textBufferSetText :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> Text -> Int32 -> m ()

-- | Undoes the last undoable action on the buffer, if there is one.
textBufferUndo :: (HasCallStack, MonadIO m, IsTextBuffer a) => a -> m ()

-- | Get the value of the “<tt>can-redo</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #canRedo
--   </pre>
getTextBufferCanRedo :: (MonadIO m, IsTextBuffer o) => o -> m Bool

-- | Get the value of the “<tt>can-undo</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #canUndo
--   </pre>
getTextBufferCanUndo :: (MonadIO m, IsTextBuffer o) => o -> m Bool

-- | Get the value of the “<tt>cursor-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #cursorPosition
--   </pre>
getTextBufferCursorPosition :: (MonadIO m, IsTextBuffer o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-undo</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextBufferEnableUndo :: (IsTextBuffer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-undo</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #enableUndo
--   </pre>
getTextBufferEnableUndo :: (MonadIO m, IsTextBuffer o) => o -> m Bool

-- | Set the value of the “<tt>enable-undo</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textBuffer [ #enableUndo <a>:=</a> value ]
--   </pre>
setTextBufferEnableUndo :: (MonadIO m, IsTextBuffer o) => o -> Bool -> m ()

-- | Get the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #hasSelection
--   </pre>
getTextBufferHasSelection :: (MonadIO m, IsTextBuffer o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tag-table</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextBufferTagTable :: (IsTextBuffer o, MonadIO m, IsTextTagTable a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>tag-table</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #tagTable
--   </pre>
getTextBufferTagTable :: (MonadIO m, IsTextBuffer o) => o -> m TextTagTable

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextBufferText :: (IsTextBuffer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> textBuffer #text
--   </pre>
getTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> textBuffer [ #text <a>:=</a> value ]
--   </pre>
setTextBufferText :: (MonadIO m, IsTextBuffer o) => o -> Text -> m ()

-- | Emitted to apply a tag to a range of text in a <tt>GtkTextBuffer</tt>.
--   
--   Applying actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>start</tt></i> and <i><tt>end</tt></i> iters (or
--   has to revalidate them).
--   
--   See also: <a>textBufferApplyTag</a>,
--   <a>TextBuffer</a>.<tt><i>insert_with_tags</i></tt>(),
--   <a>textBufferInsertRange</a>.
type TextBufferApplyTagCallback = TextTag -> TextIter -> TextIter -> IO ()

-- | Connect a signal handler for the <a>applyTag</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #applyTag callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferApplyTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applyTag</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #applyTag callback
--   </pre>
onTextBufferApplyTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferApplyTagCallback) -> m SignalHandlerId

-- | Emitted at the beginning of a single user-visible operation on a
--   <tt>GtkTextBuffer</tt>.
--   
--   See also: <a>textBufferBeginUserAction</a>,
--   <a>textBufferInsertInteractive</a>,
--   <a>textBufferInsertRangeInteractive</a>,
--   <a>textBufferDeleteInteractive</a>, <a>textBufferBackspace</a>,
--   <a>textBufferDeleteSelection</a>.
type TextBufferBeginUserActionCallback = IO ()

-- | Connect a signal handler for the <a>beginUserAction</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #beginUserAction callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferBeginUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>beginUserAction</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #beginUserAction callback
--   </pre>
onTextBufferBeginUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferBeginUserActionCallback) -> m SignalHandlerId

-- | Emitted when the content of a <tt>GtkTextBuffer</tt> has changed.
type TextBufferChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #changed callback
--   </pre>
onTextBufferChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferChangedCallback) -> m SignalHandlerId

-- | Emitted to delete a range from a <tt>GtkTextBuffer</tt>.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>start</tt></i> and <i><tt>end</tt></i> iters (or
--   has to revalidate them). The default signal handler revalidates the
--   <i><tt>start</tt></i> and <i><tt>end</tt></i> iters to both point to
--   the location where text was deleted. Handlers which run after the
--   default handler (see <tt><i>g_signal_connect_after()</i></tt>) do not
--   have access to the deleted text.
--   
--   See also: <a>textBufferDelete</a>.
type TextBufferDeleteRangeCallback = TextIter -> TextIter -> IO ()

-- | Connect a signal handler for the <a>deleteRange</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #deleteRange callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferDeleteRangeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteRange</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #deleteRange callback
--   </pre>
onTextBufferDeleteRange :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferDeleteRangeCallback) -> m SignalHandlerId

-- | Emitted at the end of a single user-visible operation on the
--   <tt>GtkTextBuffer</tt>.
--   
--   See also: <a>textBufferEndUserAction</a>,
--   <a>textBufferInsertInteractive</a>,
--   <a>textBufferInsertRangeInteractive</a>,
--   <a>textBufferDeleteInteractive</a>, <a>textBufferBackspace</a>,
--   <a>textBufferDeleteSelection</a>, <a>textBufferBackspace</a>.
type TextBufferEndUserActionCallback = IO ()

-- | Connect a signal handler for the <a>endUserAction</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #endUserAction callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferEndUserActionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>endUserAction</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #endUserAction callback
--   </pre>
onTextBufferEndUserAction :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferEndUserActionCallback) -> m SignalHandlerId

-- | Emitted to insert a <tt>GtkTextChildAnchor</tt> in a
--   <tt>GtkTextBuffer</tt>.
--   
--   Insertion actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>location</tt></i> iter (or has to revalidate
--   it). The default signal handler revalidates it to be placed after the
--   inserted <i><tt>anchor</tt></i>.
--   
--   See also: <a>textBufferInsertChildAnchor</a>.
type TextBufferInsertChildAnchorCallback = TextIter -> TextChildAnchor -> IO ()

-- | Connect a signal handler for the <a>insertChildAnchor</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #insertChildAnchor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertChildAnchorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertChildAnchor</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #insertChildAnchor callback
--   </pre>
onTextBufferInsertChildAnchor :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertChildAnchorCallback) -> m SignalHandlerId

-- | Emitted to insert a <tt>GdkPaintable</tt> in a <tt>GtkTextBuffer</tt>.
--   
--   Insertion actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>location</tt></i> iter (or has to revalidate
--   it). The default signal handler revalidates it to be placed after the
--   inserted <i><tt>paintable</tt></i>.
--   
--   See also: <a>textBufferInsertPaintable</a>.
type TextBufferInsertPaintableCallback = TextIter -> Paintable -> IO ()

-- | Connect a signal handler for the <a>insertPaintable</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #insertPaintable callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferInsertPaintable :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertPaintableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertPaintable</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #insertPaintable callback
--   </pre>
onTextBufferInsertPaintable :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertPaintableCallback) -> m SignalHandlerId

-- | Emitted to insert text in a <tt>GtkTextBuffer</tt>.
--   
--   Insertion actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>location</tt></i> iter (or has to revalidate
--   it). The default signal handler revalidates it to point to the end of
--   the inserted text.
--   
--   See also: <a>textBufferInsert</a>, <a>textBufferInsertRange</a>.
type TextBufferInsertTextCallback = TextIter -> Text -> Int32 -> IO ()

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #insertText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #insertText callback
--   </pre>
onTextBufferInsertText :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferInsertTextCallback) -> m SignalHandlerId

-- | Emitted as notification after a <tt>GtkTextMark</tt> is deleted.
--   
--   See also: <a>textBufferDeleteMark</a>.
type TextBufferMarkDeletedCallback = TextMark -> IO ()

-- | Connect a signal handler for the <a>markDeleted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #markDeleted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>markDeleted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #markDeleted callback
--   </pre>
onTextBufferMarkDeleted :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkDeletedCallback) -> m SignalHandlerId

-- | Emitted as notification after a <tt>GtkTextMark</tt> is set.
--   
--   See also: <a>textBufferCreateMark</a>, <a>textBufferMoveMark</a>.
type TextBufferMarkSetCallback = TextIter -> TextMark -> IO ()

-- | Connect a signal handler for the <a>markSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #markSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>markSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #markSet callback
--   </pre>
onTextBufferMarkSet :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferMarkSetCallback) -> m SignalHandlerId

-- | Emitted when the modified bit of a <tt>GtkTextBuffer</tt> flips.
--   
--   See also: <a>textBufferSetModified</a>.
type TextBufferModifiedChangedCallback = IO ()

-- | Connect a signal handler for the <a>modifiedChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #modifiedChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferModifiedChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>modifiedChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #modifiedChanged callback
--   </pre>
onTextBufferModifiedChanged :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferModifiedChangedCallback) -> m SignalHandlerId

-- | Emitted after paste operation has been completed.
--   
--   This is useful to properly scroll the view to the end of the pasted
--   text. See <a>textBufferPasteClipboard</a> for more details.
type TextBufferPasteDoneCallback = Clipboard -> IO ()

-- | Connect a signal handler for the <a>pasteDone</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #pasteDone callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferPasteDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteDone</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #pasteDone callback
--   </pre>
onTextBufferPasteDone :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferPasteDoneCallback) -> m SignalHandlerId

-- | Emitted when a request has been made to redo the previously undone
--   operation.
type TextBufferRedoCallback = IO ()

-- | Connect a signal handler for the <a>redo</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #redo callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferRedo :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRedoCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>redo</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #redo callback
--   </pre>
onTextBufferRedo :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRedoCallback) -> m SignalHandlerId

-- | Emitted to remove all occurrences of <i><tt>tag</tt></i> from a range
--   of text in a <tt>GtkTextBuffer</tt>.
--   
--   Removal actually occurs in the default handler.
--   
--   Note that if your handler runs before the default handler it must not
--   invalidate the <i><tt>start</tt></i> and <i><tt>end</tt></i> iters (or
--   has to revalidate them).
--   
--   See also: <a>textBufferRemoveTag</a>.
type TextBufferRemoveTagCallback = TextTag -> TextIter -> TextIter -> IO ()

-- | Connect a signal handler for the <a>removeTag</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #removeTag callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRemoveTagCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeTag</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #removeTag callback
--   </pre>
onTextBufferRemoveTag :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferRemoveTagCallback) -> m SignalHandlerId

-- | Emitted when a request has been made to undo the previous operation or
--   set of operations that have been grouped together.
type TextBufferUndoCallback = IO ()

-- | Connect a signal handler for the <a>undo</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> textBuffer #undo callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBufferUndo :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferUndoCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>undo</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> textBuffer #undo callback
--   </pre>
onTextBufferUndo :: (IsTextBuffer a, MonadIO m) => a -> ((?self :: a) => TextBufferUndoCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.TextBuffer.TextBuffer
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.TextBuffer.TextBuffer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.TextBuffer.TextBuffer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.TextBuffer.TextBuffer)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.TextBuffer.TextBuffer o) => GI.Gtk.Objects.TextBuffer.IsTextBuffer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.TextBuffer.TextBuffer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.TextBuffer.TextBuffer


-- | A single-line text entry.
--   
--   <tt>GtkText</tt> is the common implementation of single-line text
--   editing that is shared between <a>Entry</a>, <a>PasswordEntry</a>,
--   <a>SpinButton</a>, and other widgets. In all of these, a
--   <tt>GtkText</tt> instance is used as the delegate for the
--   <a>Editable</a> implementation.
--   
--   A large number of key bindings s supported by default. If the entered
--   text is longer than the allocation of the widget, the widget will
--   scroll so that the cursor position is visible.
--   
--   When using an entry for passwords and other sensitive information, it
--   can be put into “password mode” using <a>textSetVisibility</a>. In
--   this mode, entered text is displayed using an “invisible” character.
--   By default, GTK picks the best invisible character that is available
--   in the current font, but it can be changed with
--   <a>textSetInvisibleChar</a>.
--   
--   If you want to add icons or progress display in an entry, look at
--   <a>Entry</a>. There are other alternatives for more specialized use
--   cases, such as <a>SearchEntry</a>.
--   
--   If you need multi-line editable text, use <a>TextView</a>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkText</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;F10&lt;/kbd&gt; or
--   &lt;kbd&gt;Menu&lt;/kbd&gt; opens the context menu.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;A&lt;/kbd&gt; or
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;&amp;sol;&lt;/kbd&gt; selects
--   all the text.</li>
--   
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;A&lt;/kbd&gt;
--   or &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;&amp;bsol;&lt;/kbd&gt;
--   unselects all.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Z&lt;/kbd&gt; undoes the
--   last modification.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Y&lt;/kbd&gt; or
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Z&lt;/kbd&gt;
--   redoes the last undone modification.</li>
--   
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;T&lt;/kbd&gt;
--   toggles the text direction.</li>
--   <li>&lt;kbd&gt;Clear&lt;/kbd&gt; clears the content.</li>
--   </ul>
--   
--   Additionally, the following signals have default keybindings:
--   
--   <ul>
--   <li><a>Text::activate</a></li>
--   <li><a>Text::backspace</a></li>
--   <li><a>Text::copyClipboard</a></li>
--   <li><a>Text::cutClipboard</a></li>
--   <li><a>Text::deleteFromCursor</a></li>
--   <li><a>Text::insertEmoji</a></li>
--   <li><a>Text::moveCursor</a></li>
--   <li><a>Text::pasteClipboard</a></li>
--   <li><a>Text::toggleOverwrite</a></li>
--   </ul>
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkText</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>clipboard.copy</tt> copies the contents to the clipboard.</li>
--   <li><tt>clipboard.cut</tt> copies the contents to the clipboard and
--   deletes it from the widget.</li>
--   <li><tt>clipboard.paste</tt> inserts the contents of the clipboard
--   into the widget.</li>
--   <li><tt>menu.popup</tt> opens the context menu.</li>
--   <li><tt>misc.insert-emoji</tt> opens the Emoji chooser.</li>
--   <li><tt>misc.toggle-visibility</tt> toggles the
--   <tt>GtkText</tt>:visibility property.</li>
--   <li><tt>misc.toggle-direction</tt> toggles the text direction.</li>
--   <li><tt>selection.delete</tt> deletes the current selection.</li>
--   <li><tt>selection.select-all</tt> selects all of the widgets
--   content.</li>
--   <li><tt>text.redo</tt> redoes the last change to the contents.</li>
--   <li><tt>text.undo</tt> undoes the last change to the contents.</li>
--   <li><tt>text.clear</tt> removes all content.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   text[.read-only]
--   ├── placeholder
--   ├── undershoot.left
--   ├── undershoot.right
--   ├── [selection]
--   ├── [cursor-handle[.top]
--   ├── [cursor-handle.bottom]
--   ├── [block-cursor]
--   ├── [cursor-handle[.top/.bottom][.insertion-cursor]]
--   ╰── [window.popup]
--   </pre>
--   
--   <tt>GtkText</tt> has a main node with the name <tt>text</tt>.
--   Depending on the properties of the widget, the <tt>.read-only</tt>
--   style class may appear.
--   
--   When the entry has a selection, it adds a subnode with the name
--   <tt>selection</tt>.
--   
--   When the entry is in overwrite mode, it adds a subnode with the name
--   <tt>block-cursor</tt> that determines how the block cursor is drawn.
--   
--   The CSS node for a context menu is added as a subnode with the name
--   <tt>popup</tt>.
--   
--   The <tt>undershoot</tt> nodes are used to draw the underflow
--   indication when content is scrolled out of view. These nodes get the
--   <tt>.left</tt> or <tt>.right</tt> style class added depending on where
--   the indication is drawn.
--   
--   When touch is used and touch selection handles are shown, they are
--   using CSS nodes with name <tt>cursor-handle</tt>. They get the
--   <tt>.top</tt> or <tt>.bottom</tt> style class depending on where they
--   are shown in relation to the selection. If there is just a single
--   handle for the text cursor, it gets the style class
--   <tt>.insertion-cursor</tt>.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkText</tt> uses the <a>AccessibleRoleNone</a> role, which causes
--   it to be skipped for accessibility. This is because <tt>GtkText</tt>
--   is expected to be used as a delegate for a <tt>GtkEditable</tt>
--   implementation that will be represented to accessibility.
module GI.Gtk.Objects.Text

-- | Memory-managed wrapper type.
newtype Text
Text :: ManagedPtr Text -> Text

-- | Type class for types which can be safely cast to <a>Text</a>, for
--   instance with <a>toText</a>.
class (GObject o, IsDescendantOf Text o) => IsText o

-- | Cast to <a>Text</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toText :: (MonadIO m, IsText o) => o -> m Text

-- | Determines the positions of the strong and weak cursors for a given
--   character position.
--   
--   The position of each cursor is stored as a zero-width rectangle. The
--   strong cursor location is the location where characters of the
--   directionality equal to the base direction are inserted. The weak
--   cursor location is the location where characters of the directionality
--   opposite to the base direction are inserted.
--   
--   The rectangle positions are in widget coordinates.
--   
--   <i>Since: 4.4</i>
textComputeCursorExtents :: (HasCallStack, MonadIO m, IsText a) => a -> CSize -> m (Rect, Rect)

-- | Returns whether pressing &lt;kbd&gt;Enter&lt;/kbd&gt; will activate
--   the default widget for the window containing the widget.
--   
--   See <a>textSetActivatesDefault</a>.
textGetActivatesDefault :: (HasCallStack, MonadIO m, IsText a) => a -> m Bool

-- | Gets the attribute list that was set on the text widget.
--   
--   See <a>textSetAttributes</a>.
textGetAttributes :: (HasCallStack, MonadIO m, IsText a) => a -> m (Maybe AttrList)

-- | Get the entry buffer object which holds the text for this widget.
textGetBuffer :: (HasCallStack, MonadIO m, IsText a) => a -> m EntryBuffer

-- | Returns whether Emoji completion is enabled.
textGetEnableEmojiCompletion :: (HasCallStack, MonadIO m, IsText a) => a -> m Bool

-- | Gets the extra menu model of the text widget.
--   
--   See <a>textSetExtraMenu</a>.
textGetExtraMenu :: (HasCallStack, MonadIO m, IsText a) => a -> m (Maybe MenuModel)

-- | Gets the input hints of the text widget.
textGetInputHints :: (HasCallStack, MonadIO m, IsText a) => a -> m [InputHints]

-- | Gets the input purpose of the text widget.
textGetInputPurpose :: (HasCallStack, MonadIO m, IsText a) => a -> m InputPurpose

-- | Retrieves the character displayed when visibility is set to false.
--   
--   Note that GTK does not compute this value unless it needs it, so the
--   value returned by this function is not very useful unless it has been
--   explicitly set with <a>textSetInvisibleChar</a>.
textGetInvisibleChar :: (HasCallStack, MonadIO m, IsText a) => a -> m Char

-- | Retrieves the maximum allowed length of the contents.
--   
--   See <a>textSetMaxLength</a>.
--   
--   This is equivalent to getting <i><tt>self</tt></i>'s
--   <tt>GtkEntryBuffer</tt> and calling <a>entryBufferGetMaxLength</a> on
--   it.
textGetMaxLength :: (HasCallStack, MonadIO m, IsText a) => a -> m Int32

-- | Gets whether text is overwritten when typing.
--   
--   See <a>textSetOverwriteMode</a>.
textGetOverwriteMode :: (HasCallStack, MonadIO m, IsText a) => a -> m Bool

-- | Retrieves the text that will be displayed when the text widget is
--   empty and unfocused
--   
--   See <a>textSetPlaceholderText</a>.
textGetPlaceholderText :: (HasCallStack, MonadIO m, IsText a) => a -> m (Maybe Text)

-- | Returns whether the text widget will grow and shrink with the content.
textGetPropagateTextWidth :: (HasCallStack, MonadIO m, IsText a) => a -> m Bool

-- | Gets the tab stops for the text widget.
--   
--   See <a>textSetTabs</a>.
textGetTabs :: (HasCallStack, MonadIO m, IsText a) => a -> m (Maybe TabArray)

-- | Retrieves the length of the contents.
--   
--   This is equivalent to getting <i><tt>self</tt></i>'s
--   <tt>GtkEntryBuffer</tt> and calling <a>entryBufferGetLength</a> on it.
textGetTextLength :: (HasCallStack, MonadIO m, IsText a) => a -> m Word16

-- | Returns whether pasted text will be truncated to the first line.
textGetTruncateMultiline :: (HasCallStack, MonadIO m, IsText a) => a -> m Bool

-- | Retrieves whether the text is visible.
textGetVisibility :: (HasCallStack, MonadIO m, IsText a) => a -> m Bool

-- | Causes the text widget to have the keyboard focus.
--   
--   It behaves like <a>widgetGrabFocus</a>, except that it does not select
--   the contents of <i><tt>self</tt></i>.
--   
--   You only want to call this on some special entries which the user
--   usually doesn't want to replace all text in, such as
--   search-as-you-type entries.
textGrabFocusWithoutSelecting :: (HasCallStack, MonadIO m, IsText a) => a -> m Bool

-- | Creates a new <tt>GtkText</tt>.
textNew :: (HasCallStack, MonadIO m) => m Text

-- | Creates a new <tt>GtkText</tt> with the specified buffer.
textNewWithBuffer :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Text

-- | Sets whether pressing &lt;kbd&gt;Enter&lt;/kbd&gt; will activate the
--   default widget.
--   
--   This usually means that the dialog containing <i><tt>self</tt></i>
--   will be closed, since the default widget is usually one of the dialog
--   buttons.
textSetActivatesDefault :: (HasCallStack, MonadIO m, IsText a) => a -> Bool -> m ()

-- | Apply attributes to the contents of the text widget.
textSetAttributes :: (HasCallStack, MonadIO m, IsText a) => a -> Maybe AttrList -> m ()

-- | Set the entry buffer object which holds the text for this widget.
textSetBuffer :: (HasCallStack, MonadIO m, IsText a, IsEntryBuffer b) => a -> b -> m ()

-- | Sets whether Emoji completion is enabled.
--   
--   If it is, typing ':', followed by a recognized keyword, will pop up a
--   window with suggested Emojis matching the keyword.
textSetEnableEmojiCompletion :: (HasCallStack, MonadIO m, IsText a) => a -> Bool -> m ()

-- | Sets a menu model to add to the context menu of the text widget.
textSetExtraMenu :: (HasCallStack, MonadIO m, IsText a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets hints that allow input methods to fine-tune their behaviour.
textSetInputHints :: (HasCallStack, MonadIO m, IsText a) => a -> [InputHints] -> m ()

-- | Sets the input purpose of the text widget.
--   
--   The input purpose can be used by on-screen keyboards and other input
--   methods to adjust their behaviour.
textSetInputPurpose :: (HasCallStack, MonadIO m, IsText a) => a -> InputPurpose -> m ()

-- | Sets the character to use when in “password mode”.
--   
--   By default, GTK picks the best invisible char available in the current
--   font. If you set the invisible char to 0, then the user will get no
--   feedback at all; there will be no text on the screen as they type.
textSetInvisibleChar :: (HasCallStack, MonadIO m, IsText a) => a -> Char -> m ()

-- | Sets the maximum allowed length of the contents.
--   
--   If the current contents are longer than the given length, they will be
--   truncated to fit.
--   
--   This is equivalent to getting <i><tt>self</tt></i>'s
--   <tt>GtkEntryBuffer</tt> and calling <a>entryBufferSetMaxLength</a> on
--   it.
textSetMaxLength :: (HasCallStack, MonadIO m, IsText a) => a -> Int32 -> m ()

-- | Sets whether the text is overwritten when typing.
textSetOverwriteMode :: (HasCallStack, MonadIO m, IsText a) => a -> Bool -> m ()

-- | Sets the text to be displayed when the text widget is empty and
--   unfocused.
--   
--   This can be used to give a visual hint of the expected contents of the
--   text widget.
textSetPlaceholderText :: (HasCallStack, MonadIO m, IsText a) => a -> Maybe Text -> m ()

-- | Sets whether the text widget should grow and shrink with the content.
textSetPropagateTextWidth :: (HasCallStack, MonadIO m, IsText a) => a -> Bool -> m ()

-- | Sets tab stops for the text widget.
textSetTabs :: (HasCallStack, MonadIO m, IsText a) => a -> Maybe TabArray -> m ()

-- | Sets whether pasted text should be truncated to the first line.
textSetTruncateMultiline :: (HasCallStack, MonadIO m, IsText a) => a -> Bool -> m ()

-- | Sets whether the contents of the text widget are visible or not.
--   
--   When visibility is set to false, characters are displayed as the
--   invisible char, and it will also appear that way when the text in the
--   widget is copied to the clipboard.
--   
--   By default, GTK picks the best invisible character available in the
--   current font, but it can be changed with <a>textSetInvisibleChar</a>.
--   
--   Note that you probably want to set <a>Text:inputPurpose</a> to
--   <a>InputPurposePassword</a> or <a>InputPurposePin</a> to inform input
--   methods about the purpose of this widget, in addition to setting
--   visibility to false.
textSetVisibility :: (HasCallStack, MonadIO m, IsText a) => a -> Bool -> m ()

-- | Unsets the invisible char.
--   
--   After calling this, the default invisible char is used again.
textUnsetInvisibleChar :: (HasCallStack, MonadIO m, IsText a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activates-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextActivatesDefault :: (IsText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #activatesDefault
--   </pre>
getTextActivatesDefault :: (MonadIO m, IsText o) => o -> m Bool

-- | Set the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #activatesDefault <a>:=</a> value ]
--   </pre>
setTextActivatesDefault :: (MonadIO m, IsText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearTextAttributes :: (MonadIO m, IsText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextAttributes :: (IsText o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #attributes
--   </pre>
getTextAttributes :: (MonadIO m, IsText o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #attributes <a>:=</a> value ]
--   </pre>
setTextAttributes :: (MonadIO m, IsText o) => o -> AttrList -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buffer</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextBuffer :: (IsText o, MonadIO m, IsEntryBuffer a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #buffer
--   </pre>
getTextBuffer :: (MonadIO m, IsText o) => o -> m EntryBuffer

-- | Set the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #buffer <a>:=</a> value ]
--   </pre>
setTextBuffer :: (MonadIO m, IsText o, IsEntryBuffer a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-emoji-completion</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextEnableEmojiCompletion :: (IsText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-emoji-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #enableEmojiCompletion
--   </pre>
getTextEnableEmojiCompletion :: (MonadIO m, IsText o) => o -> m Bool

-- | Set the value of the “<tt>enable-emoji-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #enableEmojiCompletion <a>:=</a> value ]
--   </pre>
setTextEnableEmojiCompletion :: (MonadIO m, IsText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>extra-menu</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #extraMenu
--   </pre>
clearTextExtraMenu :: (MonadIO m, IsText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>extra-menu</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextExtraMenu :: (IsText o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #extraMenu
--   </pre>
getTextExtraMenu :: (MonadIO m, IsText o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #extraMenu <a>:=</a> value ]
--   </pre>
setTextExtraMenu :: (MonadIO m, IsText o, IsMenuModel a) => o -> a -> m ()

-- | Set the value of the “<tt>im-module</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #imModule
--   </pre>
clearTextImModule :: (MonadIO m, IsText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>im-module</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextImModule :: (IsText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #imModule
--   </pre>
getTextImModule :: (MonadIO m, IsText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #imModule <a>:=</a> value ]
--   </pre>
setTextImModule :: (MonadIO m, IsText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextInputHints :: (IsText o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #inputHints
--   </pre>
getTextInputHints :: (MonadIO m, IsText o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #inputHints <a>:=</a> value ]
--   </pre>
setTextInputHints :: (MonadIO m, IsText o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructTextInputPurpose :: (IsText o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #inputPurpose
--   </pre>
getTextInputPurpose :: (MonadIO m, IsText o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #inputPurpose <a>:=</a> value ]
--   </pre>
setTextInputPurpose :: (MonadIO m, IsText o) => o -> InputPurpose -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-char</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextInvisibleChar :: (IsText o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-char</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #invisibleChar
--   </pre>
getTextInvisibleChar :: (MonadIO m, IsText o) => o -> m Word32

-- | Set the value of the “<tt>invisible-char</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #invisibleChar <a>:=</a> value ]
--   </pre>
setTextInvisibleChar :: (MonadIO m, IsText o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-char-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextInvisibleCharSet :: (IsText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-char-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #invisibleCharSet
--   </pre>
getTextInvisibleCharSet :: (MonadIO m, IsText o) => o -> m Bool

-- | Set the value of the “<tt>invisible-char-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #invisibleCharSet <a>:=</a> value ]
--   </pre>
setTextInvisibleCharSet :: (MonadIO m, IsText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-length</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextMaxLength :: (IsText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #maxLength
--   </pre>
getTextMaxLength :: (MonadIO m, IsText o) => o -> m Int32

-- | Set the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #maxLength <a>:=</a> value ]
--   </pre>
setTextMaxLength :: (MonadIO m, IsText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overwrite-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextOverwriteMode :: (IsText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>overwrite-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #overwriteMode
--   </pre>
getTextOverwriteMode :: (MonadIO m, IsText o) => o -> m Bool

-- | Set the value of the “<tt>overwrite-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #overwriteMode <a>:=</a> value ]
--   </pre>
setTextOverwriteMode :: (MonadIO m, IsText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>placeholder-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #placeholderText
--   </pre>
clearTextPlaceholderText :: (MonadIO m, IsText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>placeholder-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructTextPlaceholderText :: (IsText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #placeholderText
--   </pre>
getTextPlaceholderText :: (MonadIO m, IsText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #placeholderText <a>:=</a> value ]
--   </pre>
setTextPlaceholderText :: (MonadIO m, IsText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagate-text-width</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextPropagateTextWidth :: (IsText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>propagate-text-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #propagateTextWidth
--   </pre>
getTextPropagateTextWidth :: (MonadIO m, IsText o) => o -> m Bool

-- | Set the value of the “<tt>propagate-text-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #propagateTextWidth <a>:=</a> value ]
--   </pre>
setTextPropagateTextWidth :: (MonadIO m, IsText o) => o -> Bool -> m ()

-- | Get the value of the “<tt>scroll-offset</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #scrollOffset
--   </pre>
getTextScrollOffset :: (MonadIO m, IsText o) => o -> m Int32

-- | Set the value of the “<tt>tabs</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tabs
--   </pre>
clearTextTabs :: (MonadIO m, IsText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructTextTabs :: (IsText o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #tabs
--   </pre>
getTextTabs :: (MonadIO m, IsText o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #tabs <a>:=</a> value ]
--   </pre>
setTextTabs :: (MonadIO m, IsText o) => o -> TabArray -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>truncate-multiline</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructTextTruncateMultiline :: (IsText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>truncate-multiline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #truncateMultiline
--   </pre>
getTextTruncateMultiline :: (MonadIO m, IsText o) => o -> m Bool

-- | Set the value of the “<tt>truncate-multiline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #truncateMultiline <a>:=</a> value ]
--   </pre>
setTextTruncateMultiline :: (MonadIO m, IsText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visibility</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructTextVisibility :: (IsText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visibility</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> text #visibility
--   </pre>
getTextVisibility :: (MonadIO m, IsText o) => o -> m Bool

-- | Set the value of the “<tt>visibility</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> text [ #visibility <a>:=</a> value ]
--   </pre>
setTextVisibility :: (MonadIO m, IsText o) => o -> Bool -> m ()

-- | Emitted when the user hits the &lt;kbd&gt;Enter&lt;/kbd&gt; key.
--   
--   The default bindings for this signal are all forms of the
--   &lt;kbd&gt;Enter&lt;/kbd&gt; key.
type TextActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> text #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextActivate :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> text #activate callback
--   </pre>
onTextActivate :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextActivateCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Backspace&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Backspace&lt;/kbd&gt;.
type TextBackspaceCallback = IO ()

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> text #backspace callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextBackspace :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextBackspaceCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>backspace</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> text #backspace callback
--   </pre>
onTextBackspace :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextBackspaceCallback) -> m SignalHandlerId

-- | Emitted to copy the selection to the clipboard.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;c&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Insert&lt;/kbd&gt;.
type TextCopyClipboardCallback = IO ()

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> text #copyClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextCopyClipboard :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> text #copyClipboard callback
--   </pre>
onTextCopyClipboard :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCopyClipboardCallback) -> m SignalHandlerId

-- | Emitted to cut the selection to the clipboard.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;x&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Delete&lt;/kbd&gt;.
type TextCutClipboardCallback = IO ()

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> text #cutClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextCutClipboard :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCutClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cutClipboard</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> text #cutClipboard callback
--   </pre>
onTextCutClipboard :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextCutClipboardCallback) -> m SignalHandlerId

-- | Emitted when the user initiates a text deletion.
--   
--   This is a <a>keybinding signal</a>.
--   
--   If the <i><tt>type</tt></i> is <a>DeleteTypeChars</a>, GTK deletes the
--   selection if there is one, otherwise it deletes the requested number
--   of characters.
--   
--   The default bindings for this signal are &lt;kbd&gt;Delete&lt;/kbd&gt;
--   for deleting a character and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Delete&lt;/kbd&gt; for deleting
--   a word.
type TextDeleteFromCursorCallback = DeleteType -> Int32 -> IO ()

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> text #deleteFromCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextDeleteFromCursor :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextDeleteFromCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteFromCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> text #deleteFromCursor callback
--   </pre>
onTextDeleteFromCursor :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextDeleteFromCursorCallback) -> m SignalHandlerId

-- | Emitted when the user initiates the insertion of a fixed string at the
--   cursor.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This signal has no default bindings.
type TextInsertAtCursorCallback = Text -> IO ()

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> text #insertAtCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextInsertAtCursor :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextInsertAtCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertAtCursor</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> text #insertAtCursor callback
--   </pre>
onTextInsertAtCursor :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextInsertAtCursorCallback) -> m SignalHandlerId

-- | Emitted to present the Emoji chooser.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;.&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;;&lt;/kbd&gt;
type TextInsertEmojiCallback = IO ()

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> text #insertEmoji callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextInsertEmoji :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextInsertEmojiCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertEmoji</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> text #insertEmoji callback
--   </pre>
onTextInsertEmoji :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextInsertEmojiCallback) -> m SignalHandlerId

-- | Emitted when the user initiates a cursor movement.
--   
--   If the cursor is not visible in <i><tt>self</tt></i>, this signal
--   causes the viewport to be moved instead.
--   
--   This is a <a>keybinding signal</a>.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>GObject.signal_emit_by_name</i></tt> if they need to control
--   the cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the &lt;kbd&gt;Shift&lt;/kbd&gt; modifier extends the selection,
--   the variant without it does not. There are too many key combinations
--   to list them all here.
--   
--   <ul>
--   <li>&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;↑&lt;/kbd&gt;, &lt;kbd&gt;↓&lt;/kbd&gt; move by individual
--   characters/lines</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;, etc. move by
--   words/paragraphs</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt; and &lt;kbd&gt;End&lt;/kbd&gt; move to
--   the ends of the buffer</li>
--   </ul>
type TextMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> text #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextMoveCursor :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> text #moveCursor callback
--   </pre>
onTextMoveCursor :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextMoveCursorCallback) -> m SignalHandlerId

-- | Emitted to paste the contents of the clipboard.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;v&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Insert&lt;/kbd&gt;.
type TextPasteClipboardCallback = IO ()

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> text #pasteClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextPasteClipboard :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextPasteClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pasteClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> text #pasteClipboard callback
--   </pre>
onTextPasteClipboard :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextPasteClipboardCallback) -> m SignalHandlerId

-- | Emitted when the preedit text changes.
--   
--   If an input method is used, the typed text will not immediately be
--   committed to the buffer. So if you are interested in the text, connect
--   to this signal.
type TextPreeditChangedCallback = Text -> IO ()

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> text #preeditChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextPreeditChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> text #preeditChanged callback
--   </pre>
onTextPreeditChanged :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextPreeditChangedCallback) -> m SignalHandlerId

-- | Emitted to toggle the overwrite mode.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal is &lt;kbd&gt;Insert&lt;/kbd&gt;.
type TextToggleOverwriteCallback = IO ()

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> text #toggleOverwrite callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTextToggleOverwrite :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextToggleOverwriteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleOverwrite</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> text #toggleOverwrite callback
--   </pre>
onTextToggleOverwrite :: (IsText a, MonadIO m) => a -> ((?self :: a) => TextToggleOverwriteCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Text.Text
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Text.Text
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Text.Text
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Text.Text)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Text.Text o) => GI.Gtk.Objects.Text.IsText o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Text.Text
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Text.Text


-- | Shows a "light switch" that has two states: on or off.
--   
--   &lt;picture&gt; &lt;source srcset="switch-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkSwitch" src="switch.png"&gt; &lt;/picture&gt;
--   
--   The user can control which state should be active by clicking the
--   empty area, or by dragging the slider.
--   
--   <tt>GtkSwitch</tt> can also express situations where the underlying
--   state changes with a delay. In this case, the slider position
--   indicates the user's recent change (represented by the
--   <a>Switch:active</a> property), while the trough color indicates the
--   present underlying state (represented by the <a>Switch:state</a>
--   property).
--   
--   &lt;picture&gt; &lt;source srcset="switch-state-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="GtkSwitch with
--   delayed state change" src="switch-state.png"&gt; &lt;/picture&gt;
--   
--   See <a>Switch::stateSet</a> for details.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkSwitch</tt> supports pan and drag gestures to move the slider.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   switch
--   ├── image
--   ├── image
--   ╰── slider
--   </pre>
--   
--   <tt>GtkSwitch</tt> has four css nodes, the main node with the name
--   switch and subnodes for the slider and the on and off images. Neither
--   of them is using any style classes.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkSwitch</tt> uses the <a>AccessibleRoleSwitch</a> role.
module GI.Gtk.Objects.Switch

-- | Memory-managed wrapper type.
newtype Switch
Switch :: ManagedPtr Switch -> Switch

-- | Type class for types which can be safely cast to <a>Switch</a>, for
--   instance with <a>toSwitch</a>.
class (GObject o, IsDescendantOf Switch o) => IsSwitch o

-- | Cast to <a>Switch</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSwitch :: (MonadIO m, IsSwitch o) => o -> m Switch

-- | Gets whether the <tt>GtkSwitch</tt> is in its “on” or “off” state.
switchGetActive :: (HasCallStack, MonadIO m, IsSwitch a) => a -> m Bool

-- | Gets the underlying state of the <tt>GtkSwitch</tt>.
switchGetState :: (HasCallStack, MonadIO m, IsSwitch a) => a -> m Bool

-- | Creates a new <tt>GtkSwitch</tt> widget.
switchNew :: (HasCallStack, MonadIO m) => m Switch

-- | Changes the state of <i><tt>self</tt></i> to the desired one.
switchSetActive :: (HasCallStack, MonadIO m, IsSwitch a) => a -> Bool -> m ()

-- | Sets the underlying state of the <tt>GtkSwitch</tt>.
--   
--   This function is typically called from a <a>Switch::stateSet</a>
--   signal handler in order to set up delayed state changes.
--   
--   See <a>Switch::stateSet</a> for details.
switchSetState :: (HasCallStack, MonadIO m, IsSwitch a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSwitchActive :: (IsSwitch o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> switch #active
--   </pre>
getSwitchActive :: (MonadIO m, IsSwitch o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> switch [ #active <a>:=</a> value ]
--   </pre>
setSwitchActive :: (MonadIO m, IsSwitch o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>state</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSwitchState :: (IsSwitch o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> switch #state
--   </pre>
getSwitchState :: (MonadIO m, IsSwitch o) => o -> m Bool

-- | Set the value of the “<tt>state</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> switch [ #state <a>:=</a> value ]
--   </pre>
setSwitchState :: (MonadIO m, IsSwitch o) => o -> Bool -> m ()

-- | Emitted to animate the switch.
--   
--   Applications should never connect to this signal, but use the
--   <a>Switch:active</a> property.
type SwitchActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> switch #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSwitchActivate :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> switch #activate callback
--   </pre>
onSwitchActivate :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchActivateCallback) -> m SignalHandlerId

-- | Emitted to change the underlying state.
--   
--   The <a>stateSet</a> signal is emitted when the user changes the switch
--   position. The default handler calls <a>switchSetState</a> with the
--   value of <i><tt>state</tt></i>.
--   
--   To implement delayed state change, applications can connect to this
--   signal, initiate the change of the underlying state, and call
--   <a>switchSetState</a> when the underlying state change is complete.
--   The signal handler should return <a>True</a> to prevent the default
--   handler from running.
type SwitchStateSetCallback = Bool -> IO Bool

-- | Connect a signal handler for the <a>stateSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> switch #stateSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSwitchStateSet :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchStateSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stateSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> switch #stateSet callback
--   </pre>
onSwitchStateSet :: (IsSwitch a, MonadIO m) => a -> ((?self :: a) => SwitchStateSetCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Switch.Switch
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Switch.Switch
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Switch.Switch
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Switch.Switch)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Switch.Switch o) => GI.Gtk.Objects.Switch.IsSwitch o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Switch.Switch
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Switch.Switch


-- | Sorts items by comparing strings.
--   
--   To obtain the strings to compare, this sorter evaluates a
--   <a>Expression</a>.
--   
--   It does the comparison in a linguistically correct way using the
--   current locale by normalizing Unicode strings and possibly
--   case-folding them before performing the comparison.
module GI.Gtk.Objects.StringSorter

-- | Memory-managed wrapper type.
newtype StringSorter
StringSorter :: ManagedPtr StringSorter -> StringSorter

-- | Type class for types which can be safely cast to <a>StringSorter</a>,
--   for instance with <a>toStringSorter</a>.
class (GObject o, IsDescendantOf StringSorter o) => IsStringSorter o

-- | Cast to <a>StringSorter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStringSorter :: (MonadIO m, IsStringSorter o) => o -> m StringSorter

-- | Gets which collation method the sorter uses.
--   
--   <i>Since: 4.10</i>
stringSorterGetCollation :: (HasCallStack, MonadIO m, IsStringSorter a) => a -> m Collation

-- | Gets the expression that is evaluated to obtain strings from items.
stringSorterGetExpression :: (HasCallStack, MonadIO m, IsStringSorter a) => a -> m (Maybe Expression)

-- | Gets whether the sorter ignores case differences.
stringSorterGetIgnoreCase :: (HasCallStack, MonadIO m, IsStringSorter a) => a -> m Bool

-- | Creates a new string sorter that compares items using the given
--   <i><tt>expression</tt></i>.
--   
--   Unless an expression is set on it, this sorter will always compare
--   items as invalid.
stringSorterNew :: (HasCallStack, MonadIO m, IsExpression a) => Maybe a -> m StringSorter

-- | Sets the collation method to use for sorting.
--   
--   <i>Since: 4.10</i>
stringSorterSetCollation :: (HasCallStack, MonadIO m, IsStringSorter a) => a -> Collation -> m ()

-- | Sets the expression that is evaluated to obtain strings from items.
--   
--   The expression must have the type <tt><i>G_TYPE_STRING</i></tt>.
stringSorterSetExpression :: (HasCallStack, MonadIO m, IsStringSorter a, IsExpression b) => a -> Maybe b -> m ()

-- | Sets whether the sorter will ignore case differences.
stringSorterSetIgnoreCase :: (HasCallStack, MonadIO m, IsStringSorter a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>collation</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStringSorterCollation :: (IsStringSorter o, MonadIO m) => Collation -> m (GValueConstruct o)

-- | Get the value of the “<tt>collation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringSorter #collation
--   </pre>
getStringSorterCollation :: (MonadIO m, IsStringSorter o) => o -> m Collation

-- | Set the value of the “<tt>collation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stringSorter [ #collation <a>:=</a> value ]
--   </pre>
setStringSorterCollation :: (MonadIO m, IsStringSorter o) => o -> Collation -> m ()

-- | Set the value of the “<tt>expression</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #expression
--   </pre>
clearStringSorterExpression :: (MonadIO m, IsStringSorter o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expression</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStringSorterExpression :: (IsStringSorter o, MonadIO m, IsExpression a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringSorter #expression
--   </pre>
getStringSorterExpression :: (MonadIO m, IsStringSorter o) => o -> m (Maybe Expression)

-- | Set the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stringSorter [ #expression <a>:=</a> value ]
--   </pre>
setStringSorterExpression :: (MonadIO m, IsStringSorter o, IsExpression a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ignore-case</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStringSorterIgnoreCase :: (IsStringSorter o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>ignore-case</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringSorter #ignoreCase
--   </pre>
getStringSorterIgnoreCase :: (MonadIO m, IsStringSorter o) => o -> m Bool

-- | Set the value of the “<tt>ignore-case</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stringSorter [ #ignoreCase <a>:=</a> value ]
--   </pre>
setStringSorterIgnoreCase :: (MonadIO m, IsStringSorter o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.StringSorter.StringSorter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StringSorter.StringSorter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StringSorter.StringSorter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StringSorter.StringSorter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StringSorter.StringSorter o) => GI.Gtk.Objects.StringSorter.IsStringSorter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StringSorter.StringSorter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StringSorter.StringSorter


-- | Determines whether to include items by comparing strings to a fixed
--   search term.
--   
--   The strings are obtained from the items by evaluating an expression
--   set with <a>stringFilterSetExpression</a>, and they are compared
--   against a search term set with <a>stringFilterSetSearch</a>.
--   
--   <tt>GtkStringFilter</tt> has several different modes of comparison -
--   it can match the whole string, just a prefix, or any substring. Use
--   <a>stringFilterSetMatchMode</a> choose a mode.
--   
--   It is also possible to make case-insensitive comparisons, with
--   <a>stringFilterSetIgnoreCase</a>.
module GI.Gtk.Objects.StringFilter

-- | Memory-managed wrapper type.
newtype StringFilter
StringFilter :: ManagedPtr StringFilter -> StringFilter

-- | Type class for types which can be safely cast to <a>StringFilter</a>,
--   for instance with <a>toStringFilter</a>.
class (GObject o, IsDescendantOf StringFilter o) => IsStringFilter o

-- | Cast to <a>StringFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStringFilter :: (MonadIO m, IsStringFilter o) => o -> m StringFilter

-- | Gets the expression that the string filter uses to obtain strings from
--   items.
stringFilterGetExpression :: (HasCallStack, MonadIO m, IsStringFilter a) => a -> m (Maybe Expression)

-- | Returns whether the filter ignores case differences.
stringFilterGetIgnoreCase :: (HasCallStack, MonadIO m, IsStringFilter a) => a -> m Bool

-- | Returns the match mode that the filter is using.
stringFilterGetMatchMode :: (HasCallStack, MonadIO m, IsStringFilter a) => a -> m StringFilterMatchMode

-- | Gets the search term.
stringFilterGetSearch :: (HasCallStack, MonadIO m, IsStringFilter a) => a -> m (Maybe Text)

-- | Creates a new string filter.
--   
--   You will want to set up the filter by providing a string to search for
--   and by providing a property to look up on the item.
stringFilterNew :: (HasCallStack, MonadIO m, IsExpression a) => Maybe a -> m StringFilter

-- | Sets the expression that the string filter uses to obtain strings from
--   items.
--   
--   The expression must have a value type of <tt>G_TYPE_STRING</tt>.
stringFilterSetExpression :: (HasCallStack, MonadIO m, IsStringFilter a, IsExpression b) => a -> Maybe b -> m ()

-- | Sets whether the filter ignores case differences.
stringFilterSetIgnoreCase :: (HasCallStack, MonadIO m, IsStringFilter a) => a -> Bool -> m ()

-- | Sets the match mode for the filter.
stringFilterSetMatchMode :: (HasCallStack, MonadIO m, IsStringFilter a) => a -> StringFilterMatchMode -> m ()

-- | Sets the string to search for.
stringFilterSetSearch :: (HasCallStack, MonadIO m, IsStringFilter a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>expression</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #expression
--   </pre>
clearStringFilterExpression :: (MonadIO m, IsStringFilter o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expression</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStringFilterExpression :: (IsStringFilter o, MonadIO m, IsExpression a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringFilter #expression
--   </pre>
getStringFilterExpression :: (MonadIO m, IsStringFilter o) => o -> m (Maybe Expression)

-- | Set the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stringFilter [ #expression <a>:=</a> value ]
--   </pre>
setStringFilterExpression :: (MonadIO m, IsStringFilter o, IsExpression a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ignore-case</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStringFilterIgnoreCase :: (IsStringFilter o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>ignore-case</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringFilter #ignoreCase
--   </pre>
getStringFilterIgnoreCase :: (MonadIO m, IsStringFilter o) => o -> m Bool

-- | Set the value of the “<tt>ignore-case</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stringFilter [ #ignoreCase <a>:=</a> value ]
--   </pre>
setStringFilterIgnoreCase :: (MonadIO m, IsStringFilter o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>match-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStringFilterMatchMode :: (IsStringFilter o, MonadIO m) => StringFilterMatchMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>match-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringFilter #matchMode
--   </pre>
getStringFilterMatchMode :: (MonadIO m, IsStringFilter o) => o -> m StringFilterMatchMode

-- | Set the value of the “<tt>match-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stringFilter [ #matchMode <a>:=</a> value ]
--   </pre>
setStringFilterMatchMode :: (MonadIO m, IsStringFilter o) => o -> StringFilterMatchMode -> m ()

-- | Set the value of the “<tt>search</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #search
--   </pre>
clearStringFilterSearch :: (MonadIO m, IsStringFilter o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStringFilterSearch :: (IsStringFilter o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stringFilter #search
--   </pre>
getStringFilterSearch :: (MonadIO m, IsStringFilter o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stringFilter [ #search <a>:=</a> value ]
--   </pre>
setStringFilterSearch :: (MonadIO m, IsStringFilter o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.StringFilter.StringFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StringFilter.StringFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StringFilter.StringFilter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StringFilter.StringFilter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StringFilter.StringFilter o) => GI.Gtk.Objects.StringFilter.IsStringFilter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StringFilter.StringFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StringFilter.StringFilter


-- | A <tt>GtkStatusbar</tt> widget is usually placed along the bottom of
--   an application's main <a>Window</a>.
--   
--   &lt;picture&gt; &lt;source srcset="statusbar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkStatusbar" src="statusbar.png"&gt; &lt;/picture&gt;
--   
--   A <tt>GtkStatusBar</tt> may provide a regular commentary of the
--   application's status (as is usually the case in a web browser, for
--   example), or may be used to simply output a message when the status
--   changes, (when an upload is complete in an FTP client, for example).
--   
--   Status bars in GTK maintain a stack of messages. The message at the
--   top of the each bar’s stack is the one that will currently be
--   displayed.
--   
--   Any messages added to a statusbar’s stack must specify a context id
--   that is used to uniquely identify the source of a message. This
--   context id can be generated by <a>statusbarGetContextId</a>, given a
--   message and the statusbar that it will be added to. Note that messages
--   are stored in a stack, and when choosing which message to display, the
--   stack structure is adhered to, regardless of the context identifier of
--   a message.
--   
--   One could say that a statusbar maintains one stack of messages for
--   display purposes, but allows multiple message producers to maintain
--   sub-stacks of the messages they produced (via context ids).
--   
--   Status bars are created using <a>statusbarNew</a>.
--   
--   Messages are added to the bar’s stack with <a>statusbarPush</a>.
--   
--   The message at the top of the stack can be removed using
--   <a>statusbarPop</a>. A message can be removed from anywhere in the
--   stack if its message id was recorded at the time it was added. This is
--   done using <a>statusbarRemove</a>.
--   
--   <h2>CSS node</h2>
--   
--   <tt>GtkStatusbar</tt> has a single CSS node with name
--   <tt>statusbar</tt>.
module GI.Gtk.Objects.Statusbar

-- | Memory-managed wrapper type.
newtype Statusbar
Statusbar :: ManagedPtr Statusbar -> Statusbar

-- | Type class for types which can be safely cast to <a>Statusbar</a>, for
--   instance with <a>toStatusbar</a>.
class (GObject o, IsDescendantOf Statusbar o) => IsStatusbar o

-- | Cast to <a>Statusbar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStatusbar :: (MonadIO m, IsStatusbar o) => o -> m Statusbar

-- | Returns a new context identifier, given a description of the actual
--   context.
--   
--   Note that the description is not shown in the UI.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
statusbarGetContextId :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Text -> m Word32

-- | Creates a new <tt>GtkStatusbar</tt> ready for messages.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
statusbarNew :: (HasCallStack, MonadIO m) => m Statusbar

-- | Removes the first message in the <tt>GtkStatusbar</tt>’s stack with
--   the given context id.
--   
--   Note that this may not change the displayed message, if the message at
--   the top of the stack has a different context id.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
statusbarPop :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> m ()

-- | Pushes a new message onto a statusbar’s stack.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
statusbarPush :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> Text -> m Word32

-- | Forces the removal of a message from a statusbar’s stack. The exact
--   <i><tt>contextId</tt></i> and <i><tt>messageId</tt></i> must be
--   specified.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
statusbarRemove :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> Word32 -> m ()

-- | Forces the removal of all messages from a statusbar's stack with the
--   exact <i><tt>contextId</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
statusbarRemoveAll :: (HasCallStack, MonadIO m, IsStatusbar a) => a -> Word32 -> m ()

-- | Emitted whenever a new message is popped off a statusbar's stack.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
type StatusbarTextPoppedCallback = Word32 -> Text -> IO ()

-- | Connect a signal handler for the <a>textPopped</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusbar #textPopped callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusbarTextPopped :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>textPopped</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusbar #textPopped callback
--   </pre>
onStatusbarTextPopped :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPoppedCallback) -> m SignalHandlerId

-- | Emitted whenever a new message gets pushed onto a statusbar's stack.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
type StatusbarTextPushedCallback = Word32 -> Text -> IO ()

-- | Connect a signal handler for the <a>textPushed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> statusbar #textPushed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterStatusbarTextPushed :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPushedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>textPushed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> statusbar #textPushed callback
--   </pre>
onStatusbarTextPushed :: (IsStatusbar a, MonadIO m) => a -> ((?self :: a) => StatusbarTextPushedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Statusbar.Statusbar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Statusbar.Statusbar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Statusbar.Statusbar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Statusbar.Statusbar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Statusbar.Statusbar o) => GI.Gtk.Objects.Statusbar.IsStatusbar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Statusbar.Statusbar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Statusbar.Statusbar


-- | Shows a row of buttons to switch between <tt>GtkStack</tt> pages.
--   
--   &lt;picture&gt; &lt;source srcset="stackswitcher-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkStackSwitcher" src="stackswitcher.png"&gt; &lt;/picture&gt;
--   
--   It acts as a controller for the associated <tt>GtkStack</tt>.
--   
--   All the content for the buttons comes from the properties of the
--   stacks <a>StackPage</a> objects; the button visibility in a
--   <tt>GtkStackSwitcher</tt> widget is controlled by the visibility of
--   the child in the <tt>GtkStack</tt>.
--   
--   It is possible to associate multiple <tt>GtkStackSwitcher</tt> widgets
--   with the same <tt>GtkStack</tt> widget.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkStackSwitcher</tt> has a single CSS node named stackswitcher
--   and style class .stack-switcher.
--   
--   When circumstances require it, <tt>GtkStackSwitcher</tt> adds the
--   .needs-attention style class to the widgets representing the stack
--   pages.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkStackSwitcher</tt> uses the <a>AccessibleRoleTabList</a> role
--   and uses the <a>AccessibleRoleTab</a> role for its buttons.
--   
--   <h1>Orientable</h1>
--   
--   Since GTK 4.4, <tt>GtkStackSwitcher</tt> implements
--   <tt>GtkOrientable</tt> allowing the stack switcher to be made vertical
--   with <tt>gtk_orientable_set_orientation()</tt>.
module GI.Gtk.Objects.StackSwitcher

-- | Memory-managed wrapper type.
newtype StackSwitcher
StackSwitcher :: ManagedPtr StackSwitcher -> StackSwitcher

-- | Type class for types which can be safely cast to <a>StackSwitcher</a>,
--   for instance with <a>toStackSwitcher</a>.
class (GObject o, IsDescendantOf StackSwitcher o) => IsStackSwitcher o

-- | Cast to <a>StackSwitcher</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStackSwitcher :: (MonadIO m, IsStackSwitcher o) => o -> m StackSwitcher

-- | Retrieves the stack.
stackSwitcherGetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a) => a -> m (Maybe Stack)

-- | Create a new <tt>GtkStackSwitcher</tt>.
stackSwitcherNew :: (HasCallStack, MonadIO m) => m StackSwitcher

-- | Sets the stack to control.
stackSwitcherSetStack :: (HasCallStack, MonadIO m, IsStackSwitcher a, IsStack b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>stack</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #stack
--   </pre>
clearStackSwitcherStack :: (MonadIO m, IsStackSwitcher o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stack</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackSwitcherStack :: (IsStackSwitcher o, MonadIO m, IsStack a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackSwitcher #stack
--   </pre>
getStackSwitcherStack :: (MonadIO m, IsStackSwitcher o) => o -> m (Maybe Stack)

-- | Set the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackSwitcher [ #stack <a>:=</a> value ]
--   </pre>
setStackSwitcherStack :: (MonadIO m, IsStackSwitcher o, IsStack a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.StackSwitcher.StackSwitcher
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StackSwitcher.StackSwitcher
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StackSwitcher.StackSwitcher
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StackSwitcher.StackSwitcher)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StackSwitcher.StackSwitcher o) => GI.Gtk.Objects.StackSwitcher.IsStackSwitcher o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StackSwitcher.StackSwitcher
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StackSwitcher.StackSwitcher


-- | Uses a sidebar to switch between <tt>GtkStack</tt> pages.
--   
--   &lt;picture&gt; &lt;source srcset="sidebar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkStackSidebar" src="sidebar.png"&gt; &lt;/picture&gt;
--   
--   In order to use a <tt>GtkStackSidebar</tt>, you simply use a
--   <tt>GtkStack</tt> to organize your UI flow, and add the sidebar to
--   your sidebar area. You can use <a>stackSidebarSetStack</a> to connect
--   the <tt>GtkStackSidebar</tt> to the <tt>GtkStack</tt>.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkStackSidebar</tt> has a single CSS node with name stacksidebar
--   and style class .sidebar.
--   
--   When circumstances require it, <tt>GtkStackSidebar</tt> adds the
--   .needs-attention style class to the widgets representing the stack
--   pages.
module GI.Gtk.Objects.StackSidebar

-- | Memory-managed wrapper type.
newtype StackSidebar
StackSidebar :: ManagedPtr StackSidebar -> StackSidebar

-- | Type class for types which can be safely cast to <a>StackSidebar</a>,
--   for instance with <a>toStackSidebar</a>.
class (GObject o, IsDescendantOf StackSidebar o) => IsStackSidebar o

-- | Cast to <a>StackSidebar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStackSidebar :: (MonadIO m, IsStackSidebar o) => o -> m StackSidebar

-- | Retrieves the stack.
stackSidebarGetStack :: (HasCallStack, MonadIO m, IsStackSidebar a) => a -> m (Maybe Stack)

-- | Creates a new <tt>GtkStackSidebar</tt>.
stackSidebarNew :: (HasCallStack, MonadIO m) => m StackSidebar

-- | Set the <tt>GtkStack</tt> associated with this
--   <tt>GtkStackSidebar</tt>.
--   
--   The sidebar widget will automatically update according to the order
--   and items within the given <tt>GtkStack</tt>.
stackSidebarSetStack :: (HasCallStack, MonadIO m, IsStackSidebar a, IsStack b) => a -> b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stack</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackSidebarStack :: (IsStackSidebar o, MonadIO m, IsStack a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackSidebar #stack
--   </pre>
getStackSidebarStack :: (MonadIO m, IsStackSidebar o) => o -> m (Maybe Stack)

-- | Set the value of the “<tt>stack</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackSidebar [ #stack <a>:=</a> value ]
--   </pre>
setStackSidebarStack :: (MonadIO m, IsStackSidebar o, IsStack a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.StackSidebar.StackSidebar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StackSidebar.StackSidebar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StackSidebar.StackSidebar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StackSidebar.StackSidebar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StackSidebar.StackSidebar o) => GI.Gtk.Objects.StackSidebar.IsStackSidebar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StackSidebar.StackSidebar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StackSidebar.StackSidebar


-- | An auxiliary class used by <tt>GtkStack</tt>.
module GI.Gtk.Objects.StackPage

-- | Memory-managed wrapper type.
newtype StackPage
StackPage :: ManagedPtr StackPage -> StackPage

-- | Type class for types which can be safely cast to <a>StackPage</a>, for
--   instance with <a>toStackPage</a>.
class (GObject o, IsDescendantOf StackPage o) => IsStackPage o

-- | Cast to <a>StackPage</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStackPage :: (MonadIO m, IsStackPage o) => o -> m StackPage

-- | Returns the stack child to which <i><tt>self</tt></i> belongs.
stackPageGetChild :: (HasCallStack, MonadIO m, IsStackPage a) => a -> m Widget

-- | Returns the icon name of the page.
stackPageGetIconName :: (HasCallStack, MonadIO m, IsStackPage a) => a -> m (Maybe Text)

-- | Returns the name of the page.
stackPageGetName :: (HasCallStack, MonadIO m, IsStackPage a) => a -> m (Maybe Text)

-- | Returns whether the page is marked as “needs attention”.
stackPageGetNeedsAttention :: (HasCallStack, MonadIO m, IsStackPage a) => a -> m Bool

-- | Gets the page title.
stackPageGetTitle :: (HasCallStack, MonadIO m, IsStackPage a) => a -> m (Maybe Text)

-- | Gets whether underlines in the page title indicate mnemonics.
stackPageGetUseUnderline :: (HasCallStack, MonadIO m, IsStackPage a) => a -> m Bool

-- | Returns whether <i><tt>page</tt></i> is visible in its
--   <tt>GtkStack</tt>.
--   
--   This is independent from the <a>Widget:visible</a> property of its
--   widget.
stackPageGetVisible :: (HasCallStack, MonadIO m, IsStackPage a) => a -> m Bool

-- | Sets the icon name of the page.
stackPageSetIconName :: (HasCallStack, MonadIO m, IsStackPage a) => a -> Text -> m ()

-- | Sets the name of the page.
stackPageSetName :: (HasCallStack, MonadIO m, IsStackPage a) => a -> Text -> m ()

-- | Sets whether the page is marked as “needs attention”.
stackPageSetNeedsAttention :: (HasCallStack, MonadIO m, IsStackPage a) => a -> Bool -> m ()

-- | Sets the page title.
stackPageSetTitle :: (HasCallStack, MonadIO m, IsStackPage a) => a -> Text -> m ()

-- | Sets whether underlines in the page title indicate mnemonics.
stackPageSetUseUnderline :: (HasCallStack, MonadIO m, IsStackPage a) => a -> Bool -> m ()

-- | Sets whether <i><tt>page</tt></i> is visible in its <tt>GtkStack</tt>.
stackPageSetVisible :: (HasCallStack, MonadIO m, IsStackPage a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackPageChild :: (IsStackPage o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackPage #child
--   </pre>
getStackPageChild :: (MonadIO m, IsStackPage o) => o -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructStackPageIconName :: (IsStackPage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackPage #iconName
--   </pre>
getStackPageIconName :: (MonadIO m, IsStackPage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackPage [ #iconName <a>:=</a> value ]
--   </pre>
setStackPageIconName :: (MonadIO m, IsStackPage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackPageName :: (IsStackPage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackPage #name
--   </pre>
getStackPageName :: (MonadIO m, IsStackPage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackPage [ #name <a>:=</a> value ]
--   </pre>
setStackPageName :: (MonadIO m, IsStackPage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>needs-attention</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructStackPageNeedsAttention :: (IsStackPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>needs-attention</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackPage #needsAttention
--   </pre>
getStackPageNeedsAttention :: (MonadIO m, IsStackPage o) => o -> m Bool

-- | Set the value of the “<tt>needs-attention</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackPage [ #needsAttention <a>:=</a> value ]
--   </pre>
setStackPageNeedsAttention :: (MonadIO m, IsStackPage o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackPageTitle :: (IsStackPage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackPage #title
--   </pre>
getStackPageTitle :: (MonadIO m, IsStackPage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackPage [ #title <a>:=</a> value ]
--   </pre>
setStackPageTitle :: (MonadIO m, IsStackPage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackPageUseUnderline :: (IsStackPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackPage #useUnderline
--   </pre>
getStackPageUseUnderline :: (MonadIO m, IsStackPage o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackPage [ #useUnderline <a>:=</a> value ]
--   </pre>
setStackPageUseUnderline :: (MonadIO m, IsStackPage o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructStackPageVisible :: (IsStackPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stackPage #visible
--   </pre>
getStackPageVisible :: (MonadIO m, IsStackPage o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stackPage [ #visible <a>:=</a> value ]
--   </pre>
setStackPageVisible :: (MonadIO m, IsStackPage o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.StackPage.StackPage
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.StackPage.StackPage
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.StackPage.StackPage
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.StackPage.StackPage)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.StackPage.StackPage o) => GI.Gtk.Objects.StackPage.IsStackPage o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.StackPage.StackPage
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.StackPage.StackPage


-- | Shows one of its children at a time.
--   
--   &lt;picture&gt; &lt;source srcset="stack-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkStack" src="stack.png"&gt; &lt;/picture&gt;
--   
--   In contrast to <tt>GtkNotebook</tt>, <tt>GtkStack</tt> does not
--   provide a means for users to change the visible child. Instead, a
--   separate widget such as <a>StackSwitcher</a> or <a>StackSidebar</a>
--   can be used with <tt>GtkStack</tt> to provide this functionality.
--   
--   Transitions between pages can be animated as slides or fades. This can
--   be controlled with <a>stackSetTransitionType</a>. These animations
--   respect the <a>Settings:gtkEnableAnimations</a> setting.
--   
--   <tt>GtkStack</tt> maintains a <a>StackPage</a> object for each added
--   child, which holds additional per-child properties. You obtain the
--   <tt>GtkStackPage</tt> for a child with <a>stackGetPage</a> and you can
--   obtain a <tt>GtkSelectionModel</tt> containing all the pages with
--   <a>stackGetPages</a>.
--   
--   <h1>GtkStack as GtkBuildable</h1>
--   
--   To set child-specific properties in a .ui file, create
--   <tt>GtkStackPage</tt> objects explicitly, and set the child widget as
--   a property on it:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkStack" id="stack"&gt;
--     &lt;child&gt;
--       &lt;object class="GtkStackPage"&gt;
--         &lt;property name="name"&gt;page1&lt;/property&gt;
--         &lt;property name="title"&gt;In the beginning…&lt;/property&gt;
--         &lt;property name="child"&gt;
--           &lt;object class="GtkLabel"&gt;
--             &lt;property name="label"&gt;It was dark&lt;/property&gt;
--           &lt;/object&gt;
--         &lt;/property&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   </pre>
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkStack</tt> has a single CSS node named stack.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkStack</tt> uses the <a>AccessibleRoleTabPanel</a> role for the
--   stack pages, which are the accessible parent objects of the child
--   widgets.
module GI.Gtk.Objects.Stack

-- | Memory-managed wrapper type.
newtype Stack
Stack :: ManagedPtr Stack -> Stack

-- | Type class for types which can be safely cast to <a>Stack</a>, for
--   instance with <a>toStack</a>.
class (GObject o, IsDescendantOf Stack o) => IsStack o

-- | Cast to <a>Stack</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toStack :: (MonadIO m, IsStack o) => o -> m Stack

-- | Adds a child to <i><tt>stack</tt></i>.
stackAddChild :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> m StackPage

-- | Adds a child to <i><tt>stack</tt></i>.
--   
--   The child is identified by the <i><tt>name</tt></i>.
stackAddNamed :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> Maybe Text -> m StackPage

-- | Adds a child to <i><tt>stack</tt></i>.
--   
--   The child is identified by the <i><tt>name</tt></i>. The
--   <i><tt>title</tt></i> will be used by <tt>GtkStackSwitcher</tt> to
--   represent <i><tt>child</tt></i> in a tab bar, so it should be short.
stackAddTitled :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> Maybe Text -> Text -> m StackPage

-- | Finds the child with the name given as the argument.
--   
--   Returns <a>Nothing</a> if there is no child with this name.
stackGetChildByName :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> m (Maybe Widget)

-- | Gets whether <i><tt>stack</tt></i> is horizontally homogeneous.
stackGetHhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Returns whether the <tt>GtkStack</tt> is set up to interpolate between
--   the sizes of children on page switch.
stackGetInterpolateSize :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Returns the <tt>GtkStackPage</tt> object for <i><tt>child</tt></i>.
stackGetPage :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> m StackPage

-- | Returns a <tt>GListModel</tt> that contains the pages of the stack.
--   
--   This can be used to keep an up-to-date view. The model also implements
--   <a>SelectionModel</a> and can be used to track and modify the visible
--   page.
stackGetPages :: (HasCallStack, MonadIO m, IsStack a) => a -> m SelectionModel

-- | Returns the amount of time (in milliseconds) that transitions between
--   pages in <i><tt>stack</tt></i> will take.
stackGetTransitionDuration :: (HasCallStack, MonadIO m, IsStack a) => a -> m Word32

-- | Returns whether the <i><tt>stack</tt></i> is currently in a transition
--   from one page to another.
stackGetTransitionRunning :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets the type of animation that will be used for transitions between
--   pages in <i><tt>stack</tt></i>.
stackGetTransitionType :: (HasCallStack, MonadIO m, IsStack a) => a -> m StackTransitionType

-- | Gets whether <i><tt>stack</tt></i> is vertically homogeneous.
stackGetVhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> m Bool

-- | Gets the currently visible child of <i><tt>stack</tt></i>.
--   
--   Returns <a>Nothing</a> if there are no visible children.
stackGetVisibleChild :: (HasCallStack, MonadIO m, IsStack a) => a -> m (Maybe Widget)

-- | Returns the name of the currently visible child of
--   <i><tt>stack</tt></i>.
--   
--   Returns <a>Nothing</a> if there is no visible child.
stackGetVisibleChildName :: (HasCallStack, MonadIO m, IsStack a) => a -> m (Maybe Text)

-- | Creates a new <tt>GtkStack</tt>.
stackNew :: (HasCallStack, MonadIO m) => m Stack

-- | Removes a child widget from <i><tt>stack</tt></i>.
stackRemove :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> m ()

-- | Sets the <tt>GtkStack</tt> to be horizontally homogeneous or not.
--   
--   If it is homogeneous, the <tt>GtkStack</tt> will request the same
--   width for all its children. If it isn't, the stack may change width
--   when a different child becomes visible.
stackSetHhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets whether or not <i><tt>stack</tt></i> will interpolate its size
--   when changing the visible child.
--   
--   If the <a>Stack:interpolateSize</a> property is set to <a>True</a>,
--   <i><tt>stack</tt></i> will interpolate its size between the current
--   one and the one it'll take after changing the visible child, according
--   to the set transition duration.
stackSetInterpolateSize :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Sets the duration that transitions between pages in
--   <i><tt>stack</tt></i> will take.
stackSetTransitionDuration :: (HasCallStack, MonadIO m, IsStack a) => a -> Word32 -> m ()

-- | Sets the type of animation that will be used for transitions between
--   pages in <i><tt>stack</tt></i>.
--   
--   Available types include various kinds of fades and slides.
--   
--   The transition type can be changed without problems at runtime, so it
--   is possible to change the animation based on the page that is about to
--   become current.
stackSetTransitionType :: (HasCallStack, MonadIO m, IsStack a) => a -> StackTransitionType -> m ()

-- | Sets the <tt>GtkStack</tt> to be vertically homogeneous or not.
--   
--   If it is homogeneous, the <tt>GtkStack</tt> will request the same
--   height for all its children. If it isn't, the stack may change height
--   when a different child becomes visible.
stackSetVhomogeneous :: (HasCallStack, MonadIO m, IsStack a) => a -> Bool -> m ()

-- | Makes <i><tt>child</tt></i> the visible child of
--   <i><tt>stack</tt></i>.
--   
--   If <i><tt>child</tt></i> is different from the currently visible
--   child, the transition between the two will be animated with the
--   current transition type of <i><tt>stack</tt></i>.
--   
--   Note that the <i><tt>child</tt></i> widget has to be visible itself
--   (see <a>widgetShow</a>) in order to become the visible child of
--   <i><tt>stack</tt></i>.
stackSetVisibleChild :: (HasCallStack, MonadIO m, IsStack a, IsWidget b) => a -> b -> m ()

-- | Makes the child with the given name visible.
--   
--   Note that the child widget has to be visible itself (see
--   <a>widgetShow</a>) in order to become the visible child of
--   <i><tt>stack</tt></i>.
stackSetVisibleChildFull :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> StackTransitionType -> m ()

-- | Makes the child with the given name visible.
--   
--   If <i><tt>child</tt></i> is different from the currently visible
--   child, the transition between the two will be animated with the
--   current transition type of <i><tt>stack</tt></i>.
--   
--   Note that the child widget has to be visible itself (see
--   <a>widgetShow</a>) in order to become the visible child of
--   <i><tt>stack</tt></i>.
stackSetVisibleChildName :: (HasCallStack, MonadIO m, IsStack a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hhomogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackHhomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>hhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #hhomogeneous
--   </pre>
getStackHhomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “<tt>hhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #hhomogeneous <a>:=</a> value ]
--   </pre>
setStackHhomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>interpolate-size</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructStackInterpolateSize :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>interpolate-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #interpolateSize
--   </pre>
getStackInterpolateSize :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “<tt>interpolate-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #interpolateSize <a>:=</a> value ]
--   </pre>
setStackInterpolateSize :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Get the value of the “<tt>pages</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #pages
--   </pre>
getStackPages :: (MonadIO m, IsStack o) => o -> m (Maybe SelectionModel)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-duration</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructStackTransitionDuration :: (IsStack o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #transitionDuration
--   </pre>
getStackTransitionDuration :: (MonadIO m, IsStack o) => o -> m Word32

-- | Set the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #transitionDuration <a>:=</a> value ]
--   </pre>
setStackTransitionDuration :: (MonadIO m, IsStack o) => o -> Word32 -> m ()

-- | Get the value of the “<tt>transition-running</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #transitionRunning
--   </pre>
getStackTransitionRunning :: (MonadIO m, IsStack o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-type</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructStackTransitionType :: (IsStack o, MonadIO m) => StackTransitionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #transitionType
--   </pre>
getStackTransitionType :: (MonadIO m, IsStack o) => o -> m StackTransitionType

-- | Set the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #transitionType <a>:=</a> value ]
--   </pre>
setStackTransitionType :: (MonadIO m, IsStack o) => o -> StackTransitionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vhomogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackVhomogeneous :: (IsStack o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>vhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #vhomogeneous
--   </pre>
getStackVhomogeneous :: (MonadIO m, IsStack o) => o -> m Bool

-- | Set the value of the “<tt>vhomogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #vhomogeneous <a>:=</a> value ]
--   </pre>
setStackVhomogeneous :: (MonadIO m, IsStack o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-child</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructStackVisibleChild :: (IsStack o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #visibleChild
--   </pre>
getStackVisibleChild :: (MonadIO m, IsStack o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>visible-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #visibleChild <a>:=</a> value ]
--   </pre>
setStackVisibleChild :: (MonadIO m, IsStack o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-child-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructStackVisibleChildName :: (IsStack o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-child-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> stack #visibleChildName
--   </pre>
getStackVisibleChildName :: (MonadIO m, IsStack o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>visible-child-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> stack [ #visibleChildName <a>:=</a> value ]
--   </pre>
setStackVisibleChildName :: (MonadIO m, IsStack o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Stack.Stack
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Stack.Stack
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Stack.Stack
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Stack.Stack)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Stack.Stack o) => GI.Gtk.Objects.Stack.IsStack o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Stack.Stack
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Stack.Stack


-- | Displays an icon-size spinning animation.
--   
--   It is often used as an alternative to a <a>ProgressBar</a> for
--   displaying indefinite activity, instead of actual progress.
--   
--   &lt;picture&gt; &lt;source srcset="spinner-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkSpinner" src="spinner.png"&gt; &lt;/picture&gt;
--   
--   To start the animation, use <a>spinnerStart</a>, to stop it use
--   <a>spinnerStop</a>.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkSpinner</tt> has a single CSS node with the name spinner. When
--   the animation is active, the :checked pseudoclass is added to this
--   node.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkSpinner</tt> uses the <a>AccessibleRoleProgressBar</a> role.
module GI.Gtk.Objects.Spinner

-- | Memory-managed wrapper type.
newtype Spinner
Spinner :: ManagedPtr Spinner -> Spinner

-- | Type class for types which can be safely cast to <a>Spinner</a>, for
--   instance with <a>toSpinner</a>.
class (GObject o, IsDescendantOf Spinner o) => IsSpinner o

-- | Cast to <a>Spinner</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSpinner :: (MonadIO m, IsSpinner o) => o -> m Spinner

-- | Returns whether the spinner is spinning.
spinnerGetSpinning :: (HasCallStack, MonadIO m, IsSpinner a) => a -> m Bool

-- | Returns a new spinner widget. Not yet started.
spinnerNew :: (HasCallStack, MonadIO m) => m Spinner

-- | Sets the activity of the spinner.
spinnerSetSpinning :: (HasCallStack, MonadIO m, IsSpinner a) => a -> Bool -> m ()

-- | Starts the animation of the spinner.
spinnerStart :: (HasCallStack, MonadIO m, IsSpinner a) => a -> m ()

-- | Stops the animation of the spinner.
spinnerStop :: (HasCallStack, MonadIO m, IsSpinner a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spinning</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSpinnerSpinning :: (IsSpinner o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>spinning</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinner #spinning
--   </pre>
getSpinnerSpinning :: (MonadIO m, IsSpinner o) => o -> m Bool

-- | Set the value of the “<tt>spinning</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinner [ #spinning <a>:=</a> value ]
--   </pre>
setSpinnerSpinning :: (MonadIO m, IsSpinner o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Spinner.Spinner
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Spinner.Spinner
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Spinner.Spinner
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Spinner.Spinner)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Spinner.Spinner o) => GI.Gtk.Objects.Spinner.IsSpinner o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Spinner.Spinner
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Spinner.Spinner


-- | Allows to enter or change numeric values.
--   
--   &lt;picture&gt; &lt;source srcset="spinbutton-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkSpinButton" src="spinbutton.png"&gt; &lt;/picture&gt;
--   
--   Rather than having to directly type a number into a <tt>GtkEntry</tt>,
--   <tt>GtkSpinButton</tt> allows the user to click on one of two arrows
--   to increment or decrement the displayed value. A value can still be
--   typed in, with the bonus that it can be checked to ensure it is in a
--   given range.
--   
--   The main properties of a <tt>GtkSpinButton</tt> are through an
--   adjustment. See the <a>Adjustment</a> documentation for more details
--   about an adjustment's properties.
--   
--   Note that <tt>GtkSpinButton</tt> will by default make its entry large
--   enough to accommodate the lower and upper bounds of the adjustment. If
--   this is not desired, the automatic sizing can be turned off by
--   explicitly setting <a>Editable:widthChars</a> to a value != -1.
--   
--   <h2>Using a GtkSpinButton to get an integer</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // Provides a function to retrieve an integer value from a GtkSpinButton
--   // and creates a spin button to model percentage values.
--   
--   int
--   grab_int_value (GtkSpinButton *button,
--                   gpointer       user_data)
--   {
--     return gtk_spin_button_get_value_as_int (button);
--   }
--   
--   void
--   create_integer_spin_button (void)
--   {
--   
--     GtkWidget *window, *button;
--     GtkAdjustment *adjustment;
--   
--     adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);
--   
--     window = gtk_window_new ();
--   
--     // creates the spinbutton, with no decimal places
--     button = gtk_spin_button_new (adjustment, 1.0, 0);
--     gtk_window_set_child (GTK_WINDOW (window), button);
--   
--     gtk_window_present (GTK_WINDOW (window));
--   }
--   </pre>
--   
--   <h2>Using a GtkSpinButton to get a floating point value</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // Provides a function to retrieve a floating point value from a
--   // GtkSpinButton, and creates a high precision spin button.
--   
--   float
--   grab_float_value (GtkSpinButton *button,
--                     gpointer       user_data)
--   {
--     return gtk_spin_button_get_value (button);
--   }
--   
--   void
--   create_floating_spin_button (void)
--   {
--     GtkWidget *window, *button;
--     GtkAdjustment *adjustment;
--   
--     adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);
--   
--     window = gtk_window_new ();
--   
--     // creates the spinbutton, with three decimal places
--     button = gtk_spin_button_new (adjustment, 0.001, 3);
--     gtk_window_set_child (GTK_WINDOW (window), button);
--   
--     gtk_window_present (GTK_WINDOW (window));
--   }
--   </pre>
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>SpinButton::changeValue</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   spinbutton.horizontal
--   ├── text
--   │    ├── undershoot.left
--   │    ╰── undershoot.right
--   ├── button.down
--   ╰── button.up
--   </pre>
--   
--   <pre>
--   spinbutton.vertical
--   ├── button.up
--   ├── text
--   │    ├── undershoot.left
--   │    ╰── undershoot.right
--   ╰── button.down
--   </pre>
--   
--   <tt>GtkSpinButton</tt>s main CSS node has the name spinbutton. It
--   creates subnodes for the entry and the two buttons, with these names.
--   The button nodes have the style classes .up and .down. The
--   <tt>GtkText</tt> subnodes (if present) are put below the text node.
--   The orientation of the spin button is reflected in the .vertical or
--   .horizontal style class on the main node.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkSpinButton</tt> uses the <a>AccessibleRoleSpinButton</a> role.
module GI.Gtk.Objects.SpinButton

-- | Memory-managed wrapper type.
newtype SpinButton
SpinButton :: ManagedPtr SpinButton -> SpinButton

-- | Type class for types which can be safely cast to <a>SpinButton</a>,
--   for instance with <a>toSpinButton</a>.
class (GObject o, IsDescendantOf SpinButton o) => IsSpinButton o

-- | Cast to <a>SpinButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSpinButton :: (MonadIO m, IsSpinButton o) => o -> m SpinButton

-- | Changes the properties of an existing spin button.
--   
--   The adjustment, climb rate, and number of decimal places are updated
--   accordingly.
spinButtonConfigure :: (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) => a -> Maybe b -> Double -> Word32 -> m ()

-- | Retrieves the value set by <a>spinButtonSetActivatesDefault</a>.
--   
--   <i>Since: 4.14</i>
spinButtonGetActivatesDefault :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Get the adjustment associated with a <tt>GtkSpinButton</tt>.
spinButtonGetAdjustment :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Adjustment

-- | Returns the acceleration rate for repeated changes.
spinButtonGetClimbRate :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Double

-- | Fetches the precision of <i><tt>spinButton</tt></i>.
spinButtonGetDigits :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Word32

-- | Gets the current step and page the increments used by
--   <i><tt>spinButton</tt></i>.
--   
--   See <a>spinButtonSetIncrements</a>.
spinButtonGetIncrements :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

-- | Returns whether non-numeric text can be typed into the spin button.
spinButtonGetNumeric :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Gets the range allowed for <i><tt>spinButton</tt></i>.
--   
--   See <a>spinButtonSetRange</a>.
spinButtonGetRange :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m (Double, Double)

-- | Returns whether the values are corrected to the nearest step.
spinButtonGetSnapToTicks :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Gets the update behavior of a spin button.
--   
--   See <a>spinButtonSetUpdatePolicy</a>.
spinButtonGetUpdatePolicy :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m SpinButtonUpdatePolicy

-- | Get the value in the <i><tt>spinButton</tt></i>.
spinButtonGetValue :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Double

-- | Get the value <i><tt>spinButton</tt></i> represented as an integer.
spinButtonGetValueAsInt :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Int32

-- | Returns whether the spin button’s value wraps around to the opposite
--   limit when the upper or lower limit of the range is exceeded.
spinButtonGetWrap :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m Bool

-- | Creates a new <tt>GtkSpinButton</tt>.
spinButtonNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Maybe a -> Double -> Word32 -> m SpinButton

-- | Creates a new <tt>GtkSpinButton</tt> with the given properties.
--   
--   This is a convenience constructor that allows creation of a numeric
--   <tt>GtkSpinButton</tt> without manually creating an adjustment. The
--   value is initially set to the minimum value and a page increment of 10
--   * <i><tt>step</tt></i> is the default. The precision of the spin
--   button is equivalent to the precision of <i><tt>step</tt></i>.
--   
--   Note that the way in which the precision is derived works best if
--   <i><tt>step</tt></i> is a power of ten. If the resulting precision is
--   not suitable for your needs, use <a>spinButtonSetDigits</a> to correct
--   it.
spinButtonNewWithRange :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m SpinButton

-- | Sets whether activating the spin button will activate the default
--   widget for the window containing the spin button.
--   
--   See <a>SpinButton::activate</a> for what counts as activation.
--   
--   <i>Since: 4.14</i>
spinButtonSetActivatesDefault :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Bool -> m ()

-- | Replaces the <tt>GtkAdjustment</tt> associated with
--   <i><tt>spinButton</tt></i>.
spinButtonSetAdjustment :: (HasCallStack, MonadIO m, IsSpinButton a, IsAdjustment b) => a -> b -> m ()

-- | Sets the acceleration rate for repeated changes when you hold down a
--   button or key.
spinButtonSetClimbRate :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> m ()

-- | Set the precision to be displayed by <i><tt>spinButton</tt></i>.
--   
--   Up to 20 digit precision is allowed.
spinButtonSetDigits :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Word32 -> m ()

-- | Sets the step and page increments for spin_button.
--   
--   This affects how quickly the value changes when the spin button’s
--   arrows are activated.
spinButtonSetIncrements :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> Double -> m ()

-- | Sets the flag that determines if non-numeric text can be typed into
--   the spin button.
spinButtonSetNumeric :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Bool -> m ()

-- | Sets the minimum and maximum allowable values for
--   <i><tt>spinButton</tt></i>.
--   
--   If the current value is outside this range, it will be adjusted to fit
--   within the range, otherwise it will remain unchanged.
spinButtonSetRange :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> Double -> m ()

-- | Sets the policy as to whether values are corrected to the nearest step
--   increment when a spin button is activated after providing an invalid
--   value.
spinButtonSetSnapToTicks :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Bool -> m ()

-- | Sets the update behavior of a spin button.
--   
--   This determines whether the spin button is always updated or only when
--   a valid value is set.
spinButtonSetUpdatePolicy :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> SpinButtonUpdatePolicy -> m ()

-- | Sets the value of <i><tt>spinButton</tt></i>.
spinButtonSetValue :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Double -> m ()

-- | Sets the flag that determines if a spin button value wraps around to
--   the opposite limit when the upper or lower limit of the range is
--   exceeded.
spinButtonSetWrap :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> Bool -> m ()

-- | Increment or decrement a spin button’s value in a specified direction
--   by a specified amount.
spinButtonSpin :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> SpinType -> Double -> m ()

-- | Manually force an update of the spin button.
spinButtonUpdate :: (HasCallStack, MonadIO m, IsSpinButton a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activates-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSpinButtonActivatesDefault :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #activatesDefault
--   </pre>
getSpinButtonActivatesDefault :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #activatesDefault <a>:=</a> value ]
--   </pre>
setSpinButtonActivatesDefault :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSpinButtonAdjustment :: (IsSpinButton o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #adjustment
--   </pre>
getSpinButtonAdjustment :: (MonadIO m, IsSpinButton o) => o -> m Adjustment

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #adjustment <a>:=</a> value ]
--   </pre>
setSpinButtonAdjustment :: (MonadIO m, IsSpinButton o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>climb-rate</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSpinButtonClimbRate :: (IsSpinButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #climbRate
--   </pre>
getSpinButtonClimbRate :: (MonadIO m, IsSpinButton o) => o -> m Double

-- | Set the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #climbRate <a>:=</a> value ]
--   </pre>
setSpinButtonClimbRate :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>digits</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonDigits :: (IsSpinButton o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #digits
--   </pre>
getSpinButtonDigits :: (MonadIO m, IsSpinButton o) => o -> m Word32

-- | Set the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #digits <a>:=</a> value ]
--   </pre>
setSpinButtonDigits :: (MonadIO m, IsSpinButton o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>numeric</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonNumeric :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>numeric</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #numeric
--   </pre>
getSpinButtonNumeric :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “<tt>numeric</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #numeric <a>:=</a> value ]
--   </pre>
setSpinButtonNumeric :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>snap-to-ticks</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSpinButtonSnapToTicks :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>snap-to-ticks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #snapToTicks
--   </pre>
getSpinButtonSnapToTicks :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “<tt>snap-to-ticks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #snapToTicks <a>:=</a> value ]
--   </pre>
setSpinButtonSnapToTicks :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>update-policy</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSpinButtonUpdatePolicy :: (IsSpinButton o, MonadIO m) => SpinButtonUpdatePolicy -> m (GValueConstruct o)

-- | Get the value of the “<tt>update-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #updatePolicy
--   </pre>
getSpinButtonUpdatePolicy :: (MonadIO m, IsSpinButton o) => o -> m SpinButtonUpdatePolicy

-- | Set the value of the “<tt>update-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #updatePolicy <a>:=</a> value ]
--   </pre>
setSpinButtonUpdatePolicy :: (MonadIO m, IsSpinButton o) => o -> SpinButtonUpdatePolicy -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonValue :: (IsSpinButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #value
--   </pre>
getSpinButtonValue :: (MonadIO m, IsSpinButton o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #value <a>:=</a> value ]
--   </pre>
setSpinButtonValue :: (MonadIO m, IsSpinButton o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSpinButtonWrap :: (IsSpinButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> spinButton #wrap
--   </pre>
getSpinButtonWrap :: (MonadIO m, IsSpinButton o) => o -> m Bool

-- | Set the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> spinButton [ #wrap <a>:=</a> value ]
--   </pre>
setSpinButtonWrap :: (MonadIO m, IsSpinButton o) => o -> Bool -> m ()

-- | Emitted when the spin button is activated.
--   
--   The keybindings for this signal are all forms of the
--   &lt;kbd&gt;Enter&lt;/kbd&gt; key.
--   
--   If the &lt;kbd&gt;Enter&lt;/kbd&gt; key results in the value being
--   committed to the spin button, then activation does not occur until
--   &lt;kbd&gt;Enter&lt;/kbd&gt; is pressed again.
--   
--   <i>Since: 4.14</i>
type SpinButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonActivate :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #activate callback
--   </pre>
onSpinButtonActivate :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonActivateCallback) -> m SignalHandlerId

-- | Emitted when the user initiates a value change.
--   
--   This is a <a>keybinding signal</a>.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal are Up/Down and PageUp/PageDown.
type SpinButtonChangeValueCallback = ScrollType -> IO ()

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #changeValue callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #changeValue callback
--   </pre>
onSpinButtonChangeValue :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonChangeValueCallback) -> m SignalHandlerId

-- | Emitted to convert the users input into a double value.
--   
--   The signal handler is expected to use <a>editableGetText</a> to
--   retrieve the text of the spinbutton and set <i><tt>newValue</tt></i>
--   to the new value.
--   
--   The default conversion uses <a>strtod</a>.
type SpinButtonInputCallback = IO (Int32, Double)

-- | Connect a signal handler for the <a>input</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #input callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>input</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #input callback
--   </pre>
onSpinButtonInput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonInputCallback) -> m SignalHandlerId

-- | Emitted to tweak the formatting of the value for display.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // show leading zeros
--   static gboolean
--   on_output (GtkSpinButton *spin,
--              gpointer       data)
--   {
--      char *text;
--      int value;
--   
--      value = gtk_spin_button_get_value_as_int (spin);
--      text = g_strdup_printf ("%02d", value);
--      gtk_editable_set_text (GTK_EDITABLE (spin), text):
--      g_free (text);
--   
--      return TRUE;
--   }
--   </pre>
type SpinButtonOutputCallback = IO Bool

-- | Connect a signal handler for the <a>output</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #output callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>output</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #output callback
--   </pre>
onSpinButtonOutput :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonOutputCallback) -> m SignalHandlerId

-- | Emitted when the value is changed.
--   
--   Also see the <a>SpinButton::output</a> signal.
type SpinButtonValueChangedCallback = IO ()

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #valueChanged callback
--   </pre>
onSpinButtonValueChanged :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonValueChangedCallback) -> m SignalHandlerId

-- | Emitted right after the spinbutton wraps from its maximum to its
--   minimum value or vice-versa.
type SpinButtonWrappedCallback = IO ()

-- | Connect a signal handler for the <a>wrapped</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> spinButton #wrapped callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>wrapped</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> spinButton #wrapped callback
--   </pre>
onSpinButtonWrapped :: (IsSpinButton a, MonadIO m) => a -> ((?self :: a) => SpinButtonWrappedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.SpinButton.SpinButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SpinButton.SpinButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SpinButton.SpinButton
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SpinButton.SpinButton)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SpinButton.SpinButton o) => GI.Gtk.Objects.SpinButton.IsSpinButton o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SpinButton.SpinButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SpinButton.SpinButton


-- | Groups widgets together so they all request the same size.
--   
--   This is typically useful when you want a column of widgets to have the
--   same size, but you can’t use a <a>Grid</a> or <a>Box</a>.
--   
--   In detail, the size requested for each widget in a
--   <tt>GtkSizeGroup</tt> is the maximum of the sizes that would have been
--   requested for each widget in the size group if they were not in the
--   size group. The [mode]<a>sizeGroupSetMode</a> of the size group
--   determines whether this applies to the horizontal size, the vertical
--   size, or both sizes.
--   
--   Note that size groups only affect the amount of space requested, not
--   the size that the widgets finally receive. If you want the widgets in
--   a <tt>GtkSizeGroup</tt> to actually be the same size, you need to pack
--   them in such a way that they get the size they request and not more.
--   In particular it doesn't make a lot of sense to set [the expand
--   flags]<a>widgetSetHexpand</a> on the widgets that are members of a
--   size group.
--   
--   <tt>GtkSizeGroup</tt> objects are referenced by each widget in the
--   size group, so once you have added all widgets to a
--   <tt>GtkSizeGroup</tt>, you can drop the initial reference to the size
--   group with <a>objectUnref</a>. If the widgets in the size group are
--   subsequently destroyed, then they will be removed from the size group
--   and drop their references on the size group; when all widgets have
--   been removed, the size group will be freed.
--   
--   Widgets can be part of multiple size groups; GTK will compute the
--   horizontal size of a widget from the horizontal requisition of all
--   widgets that can be reached from the widget by a chain of size groups
--   with mode <a>SizeGroupModeHorizontal</a> or <a>SizeGroupModeBoth</a>,
--   and the vertical size from the vertical requisition of all widgets
--   that can be reached from the widget by a chain of size groups with
--   mode <a>SizeGroupModeVertical</a> or <a>SizeGroupModeBoth</a>.
--   
--   <h1>Size groups and trading height-for-width</h1>
--   
--   ::: warning Generally, size groups don't interact well with widgets
--   that trade height for width (or width for height), such as wrappable
--   labels. Avoid using size groups with such widgets.
--   
--   A size group with mode <a>SizeGroupModeHorizontal</a> or
--   <a>SizeGroupModeVertical</a> only consults non-contextual sizes of
--   widgets other than the one being measured, since it has no knowledge
--   of what size a widget will get allocated in the other orientation.
--   This can lead to widgets in a group actually requesting different
--   contextual sizes, contrary to the purpose of <tt>GtkSizeGroup</tt>.
--   
--   In contrast, a size group with mode <a>SizeGroupModeBoth</a> can
--   properly propagate the available size in the opposite orientation when
--   measuring widgets in the group, which results in consistent and
--   accurate measurements.
--   
--   In case some mechanism other than a size group is already used to
--   ensure that widgets in a group all get the same size in one
--   orientation (for example, some common ancestor is known to allocate
--   the same width to all its children), and the size group is only really
--   needed to also make the widgets request the same size in the other
--   orientation, it is beneficial to still set the group's mode to
--   <a>SizeGroupModeBoth</a>. This lets the group assume and count on
--   sizes of the widgets in the former orientation being the same, which
--   enables it to propagate the available size as described above.
--   
--   <h1>Alternatives to size groups</h1>
--   
--   Size groups have many limitations, such as only influencing size
--   requests but not allocations, and poor height-for-width support. When
--   possible, prefer using dedicated mechanisms that can properly ensure
--   that the widgets get the same size.
--   
--   Various container widgets and layout managers support a homogeneous
--   layout mode, where they will explicitly give the same size to their
--   children (see <a>Box:homogeneous</a>). Using homogeneous mode can also
--   have large performance benefits compared to either the same container
--   in non-homogeneous mode, or to size groups.
--   
--   <a>Grid</a> can be used to position widgets into rows and columns.
--   Members of each column will have the same width among them; likewise,
--   members of each row will have the same height. On top of that, the
--   heights can be made equal between all rows with
--   <a>Grid:rowHomogeneous</a>, and the widths can be made equal between
--   all columns with <a>Grid:columnHomogeneous</a>.
--   
--   <h1>GtkSizeGroup as GtkBuildable</h1>
--   
--   Size groups can be specified in a UI definition by placing an
--   <tt>&lt;object&gt;</tt> element with <tt>class="GtkSizeGroup"</tt>
--   somewhere in the UI definition. The widgets that belong to the size
--   group are specified by a <tt>&lt;widgets&gt;</tt> element that may
--   contain multiple <tt>&lt;widget&gt;</tt> elements, one for each member
--   of the size group. The ”name” attribute gives the id of the widget.
--   
--   An example of a UI definition fragment with <tt>GtkSizeGroup</tt>:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkSizeGroup"&gt;
--     &lt;property name="mode"&gt;horizontal&lt;/property&gt;
--     &lt;widgets&gt;
--       &lt;widget name="radio1"/&gt;
--       &lt;widget name="radio2"/&gt;
--     &lt;/widgets&gt;
--   &lt;/object&gt;
--   </pre>
module GI.Gtk.Objects.SizeGroup

-- | Memory-managed wrapper type.
newtype SizeGroup
SizeGroup :: ManagedPtr SizeGroup -> SizeGroup

-- | Type class for types which can be safely cast to <a>SizeGroup</a>, for
--   instance with <a>toSizeGroup</a>.
class (GObject o, IsDescendantOf SizeGroup o) => IsSizeGroup o

-- | Cast to <a>SizeGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSizeGroup :: (MonadIO m, IsSizeGroup o) => o -> m SizeGroup

-- | Adds a widget to a <tt>GtkSizeGroup</tt>.
--   
--   In the future, the requisition of the widget will be determined as the
--   maximum of its requisition and the requisition of the other widgets in
--   the size group. Whether this applies horizontally, vertically, or in
--   both directions depends on the mode of the size group. See
--   <a>sizeGroupSetMode</a>.
--   
--   When the widget is destroyed or no longer referenced elsewhere, it
--   will be removed from the size group.
sizeGroupAddWidget :: (HasCallStack, MonadIO m, IsSizeGroup a, IsWidget b) => a -> b -> m ()

-- | Gets the current mode of the size group.
sizeGroupGetMode :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m SizeGroupMode

-- | Returns the list of widgets associated with <i><tt>sizeGroup</tt></i>.
sizeGroupGetWidgets :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> m [Widget]

-- | Create a new <tt>GtkSizeGroup</tt>.
sizeGroupNew :: (HasCallStack, MonadIO m) => SizeGroupMode -> m SizeGroup

-- | Removes a widget from a <tt>GtkSizeGroup</tt>.
sizeGroupRemoveWidget :: (HasCallStack, MonadIO m, IsSizeGroup a, IsWidget b) => a -> b -> m ()

-- | Sets the <tt>GtkSizeGroupMode</tt> of the size group.
--   
--   The mode of the size group determines whether the widgets in the size
--   group should all have the same horizontal requisition
--   (<a>SizeGroupModeHorizontal</a>) all have the same vertical
--   requisition (<a>SizeGroupModeVertical</a>), or should all have the
--   same requisition in both directions (<a>SizeGroupModeBoth</a>).
sizeGroupSetMode :: (HasCallStack, MonadIO m, IsSizeGroup a) => a -> SizeGroupMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSizeGroupMode :: (IsSizeGroup o, MonadIO m) => SizeGroupMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sizeGroup #mode
--   </pre>
getSizeGroupMode :: (MonadIO m, IsSizeGroup o) => o -> m SizeGroupMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sizeGroup [ #mode <a>:=</a> value ]
--   </pre>
setSizeGroupMode :: (MonadIO m, IsSizeGroup o) => o -> SizeGroupMode -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.SizeGroup.SizeGroup
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SizeGroup.SizeGroup
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SizeGroup.SizeGroup
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SizeGroup.SizeGroup)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SizeGroup.SizeGroup o) => GI.Gtk.Objects.SizeGroup.IsSizeGroup o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SizeGroup.SizeGroup
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SizeGroup.SizeGroup


-- | Emits a signal on a widget.
--   
--   Signals that are used in this way are referred to as keybinding
--   signals, and they are expected to be defined with the
--   <tt>G_SIGNAL_ACTION</tt> flag.
module GI.Gtk.Objects.SignalAction

-- | Memory-managed wrapper type.
newtype SignalAction
SignalAction :: ManagedPtr SignalAction -> SignalAction

-- | Type class for types which can be safely cast to <a>SignalAction</a>,
--   for instance with <a>toSignalAction</a>.
class (GObject o, IsDescendantOf SignalAction o) => IsSignalAction o

-- | Cast to <a>SignalAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSignalAction :: (MonadIO m, IsSignalAction o) => o -> m SignalAction

-- | Returns the name of the signal that will be emitted.
signalActionGetSignalName :: (HasCallStack, MonadIO m, IsSignalAction a) => a -> m Text

-- | Creates an action that when activated, emits the given action signal
--   on the provided widget.
--   
--   It will also unpack the args into arguments passed to the signal.
signalActionNew :: (HasCallStack, MonadIO m) => Text -> m SignalAction

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>signal-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSignalActionSignalName :: (IsSignalAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>signal-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalAction #signalName
--   </pre>
getSignalActionSignalName :: (MonadIO m, IsSignalAction o) => o -> m Text
instance GHC.Classes.Eq GI.Gtk.Objects.SignalAction.SignalAction
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SignalAction.SignalAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SignalAction.SignalAction
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SignalAction.SignalAction)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SignalAction.SignalAction o) => GI.Gtk.Objects.SignalAction.IsSignalAction o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SignalAction.SignalAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SignalAction.SignalAction


-- | A <tt>GtkShortcutsWindow</tt> shows information about the keyboard
--   shortcuts and gestures of an application.
--   
--   The shortcuts can be grouped, and you can have multiple sections in
--   this window, corresponding to the major modes of your application.
--   
--   Additionally, the shortcuts can be filtered by the current view, to
--   avoid showing information that is not relevant in the current
--   application context.
--   
--   The recommended way to construct a <tt>GtkShortcutsWindow</tt> is with
--   <a>Builder</a>, by using the <tt>&lt;child&gt;</tt> tag to populate a
--   <tt>GtkShortcutsWindow</tt> with one or more <a>ShortcutsSection</a>
--   objects, which contain one or more <a>ShortcutsGroup</a> instances,
--   which, in turn, contain <a>ShortcutsShortcut</a> instances.
--   
--   If you need to add a section programmatically, use
--   <a>shortcutsWindowAddSection</a> instead of <a>windowSetChild</a>, as
--   the shortcuts window manages its children directly.
--   
--   <h1>A simple example:</h1>
--   
--   &lt;picture&gt; &lt;source srcset="gedit-shortcuts-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="A simple
--   example" src="gedit-shortcuts.png"&gt; &lt;/picture&gt;
--   
--   This example has as single section. As you can see, the shortcut
--   groups are arranged in columns, and spread across several pages if
--   there are too many to find on a single page.
--   
--   The .ui file for this example can be found <a>here</a>.
--   
--   <h1>An example with multiple views:</h1>
--   
--   &lt;picture&gt; &lt;source srcset="clocks-shortcuts-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example with
--   multiple views" src="clocks-shortcuts.png"&gt; &lt;/picture&gt;
--   
--   This example shows a <tt>GtkShortcutsWindow</tt> that has been
--   configured to show only the shortcuts relevant to the “Stopwatch”
--   view.
--   
--   The .ui file for this example can be found <a>here</a>.
--   
--   <h1>An example with multiple sections:</h1>
--   
--   &lt;picture&gt; &lt;source srcset="builder-shortcuts-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example with
--   multiple sections" src="builder-shortcuts.png"&gt; &lt;/picture&gt;
--   
--   This example shows a <tt>GtkShortcutsWindow</tt> with two sections,
--   “Editor Shortcuts” and “Terminal Shortcuts”.
--   
--   The .ui file for this example can be found <a>here</a>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>ShortcutsWindow::close</a></li>
--   <li><a>ShortcutsWindow::search</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkShortcutsWindow</tt> has a single CSS node with the name
--   <tt>window</tt> and style class <tt>.shortcuts</tt>.
module GI.Gtk.Objects.ShortcutsWindow

-- | Memory-managed wrapper type.
newtype ShortcutsWindow
ShortcutsWindow :: ManagedPtr ShortcutsWindow -> ShortcutsWindow

-- | Type class for types which can be safely cast to
--   <a>ShortcutsWindow</a>, for instance with <a>toShortcutsWindow</a>.
class (GObject o, IsDescendantOf ShortcutsWindow o) => IsShortcutsWindow o

-- | Cast to <a>ShortcutsWindow</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutsWindow :: (MonadIO m, IsShortcutsWindow o) => o -> m ShortcutsWindow

-- | Adds a section to the shortcuts window.
--   
--   This is the programmatic equivalent to using <a>Builder</a> and a
--   <tt>&lt;child&gt;</tt> tag to add the child.
--   
--   Using <a>windowSetChild</a> is not appropriate as the shortcuts window
--   manages its children internally.
--   
--   <i>Since: 4.14</i>

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutsWindowAddSection :: (HasCallStack, MonadIO m, IsShortcutsWindow a, IsShortcutsSection b) => a -> b -> m ()

-- | Set the value of the “<tt>section-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #sectionName
--   </pre>
clearShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>section-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsWindowSectionName :: (IsShortcutsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsWindow #sectionName
--   </pre>
getShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsWindow [ #sectionName <a>:=</a> value ]
--   </pre>
setShortcutsWindowSectionName :: (MonadIO m, IsShortcutsWindow o) => o -> Text -> m ()

-- | Set the value of the “<tt>view-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #viewName
--   </pre>
clearShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>view-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsWindowViewName :: (IsShortcutsWindow o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsWindow #viewName
--   </pre>
getShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsWindow [ #viewName <a>:=</a> value ]
--   </pre>
setShortcutsWindowViewName :: (MonadIO m, IsShortcutsWindow o) => o -> Text -> m ()

-- | Emitted when the user uses a keybinding to close the window.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is the
--   &lt;kbd&gt;Escape&lt;/kbd&gt; key.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
type ShortcutsWindowCloseCallback = IO ()

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> shortcutsWindow #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterShortcutsWindowClose :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> shortcutsWindow #close callback
--   </pre>
onShortcutsWindowClose :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowCloseCallback) -> m SignalHandlerId

-- | Emitted when the user uses a keybinding to start a search.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Control&lt;/kbd&gt;+&lt;kbd&gt;F&lt;/kbd&gt;.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
type ShortcutsWindowSearchCallback = IO ()

-- | Connect a signal handler for the <a>search</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> shortcutsWindow #search callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterShortcutsWindowSearch :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>search</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> shortcutsWindow #search callback
--   </pre>
onShortcutsWindowSearch :: (IsShortcutsWindow a, MonadIO m) => a -> ((?self :: a) => ShortcutsWindowSearchCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow o) => GI.Gtk.Objects.ShortcutsWindow.IsShortcutsWindow o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow


-- | A <tt>GtkShortcutsShortcut</tt> represents a single keyboard shortcut
--   or gesture with a short text.
--   
--   This widget is only meant to be used with <tt>GtkShortcutsWindow</tt>.
module GI.Gtk.Objects.ShortcutsShortcut

-- | Memory-managed wrapper type.
newtype ShortcutsShortcut
ShortcutsShortcut :: ManagedPtr ShortcutsShortcut -> ShortcutsShortcut

-- | Type class for types which can be safely cast to
--   <a>ShortcutsShortcut</a>, for instance with
--   <a>toShortcutsShortcut</a>.
class (GObject o, IsDescendantOf ShortcutsShortcut o) => IsShortcutsShortcut o

-- | Cast to <a>ShortcutsShortcut</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutsShortcut :: (MonadIO m, IsShortcutsShortcut o) => o -> m ShortcutsShortcut

-- | Set the value of the “<tt>accel-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelSizeGroup
--   </pre>
clearShortcutsShortcutAccelSizeGroup :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsShortcutAccelSizeGroup :: (IsShortcutsShortcut o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #accelSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsShortcutAccelSizeGroup :: (MonadIO m, IsShortcutsShortcut o, IsSizeGroup a) => o -> a -> m ()

-- | Set the value of the “<tt>accelerator</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelerator
--   </pre>
clearShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accelerator</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutAccelerator :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #accelerator
--   </pre>
getShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #accelerator <a>:=</a> value ]
--   </pre>
setShortcutsShortcutAccelerator :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Set the value of the “<tt>action-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #actionName
--   </pre>
clearShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutActionName :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #actionName
--   </pre>
getShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #actionName <a>:=</a> value ]
--   </pre>
setShortcutsShortcutActionName :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>direction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsShortcutDirection :: (IsShortcutsShortcut o, MonadIO m) => TextDirection -> m (GValueConstruct o)

-- | Get the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #direction
--   </pre>
getShortcutsShortcutDirection :: (MonadIO m, IsShortcutsShortcut o) => o -> m TextDirection

-- | Set the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #direction <a>:=</a> value ]
--   </pre>
setShortcutsShortcutDirection :: (MonadIO m, IsShortcutsShortcut o) => o -> TextDirection -> m ()

-- | Set the value of the “<tt>icon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #icon
--   </pre>
clearShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsShortcutIcon :: (IsShortcutsShortcut o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #icon
--   </pre>
getShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>icon</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #icon <a>:=</a> value ]
--   </pre>
setShortcutsShortcutIcon :: (MonadIO m, IsShortcutsShortcut o, IsIcon a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsShortcutIconSet :: (IsShortcutsShortcut o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #iconSet
--   </pre>
getShortcutsShortcutIconSet :: (MonadIO m, IsShortcutsShortcut o) => o -> m Bool

-- | Set the value of the “<tt>icon-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #iconSet <a>:=</a> value ]
--   </pre>
setShortcutsShortcutIconSet :: (MonadIO m, IsShortcutsShortcut o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shortcut-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutShortcutType :: (IsShortcutsShortcut o, MonadIO m) => ShortcutType -> m (GValueConstruct o)

-- | Get the value of the “<tt>shortcut-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #shortcutType
--   </pre>
getShortcutsShortcutShortcutType :: (MonadIO m, IsShortcutsShortcut o) => o -> m ShortcutType

-- | Set the value of the “<tt>shortcut-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #shortcutType <a>:=</a> value ]
--   </pre>
setShortcutsShortcutShortcutType :: (MonadIO m, IsShortcutsShortcut o) => o -> ShortcutType -> m ()

-- | Set the value of the “<tt>subtitle</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #subtitle
--   </pre>
clearShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>subtitle</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsShortcutSubtitle :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #subtitle
--   </pre>
getShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #subtitle <a>:=</a> value ]
--   </pre>
setShortcutsShortcutSubtitle :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>subtitle-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsShortcutSubtitleSet :: (IsShortcutsShortcut o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>subtitle-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #subtitleSet
--   </pre>
getShortcutsShortcutSubtitleSet :: (MonadIO m, IsShortcutsShortcut o) => o -> m Bool

-- | Set the value of the “<tt>subtitle-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #subtitleSet <a>:=</a> value ]
--   </pre>
setShortcutsShortcutSubtitleSet :: (MonadIO m, IsShortcutsShortcut o) => o -> Bool -> m ()

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsShortcutTitle :: (IsShortcutsShortcut o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsShortcut #title
--   </pre>
getShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #title <a>:=</a> value ]
--   </pre>
setShortcutsShortcutTitle :: (MonadIO m, IsShortcutsShortcut o) => o -> Text -> m ()

-- | Set the value of the “<tt>title-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #titleSizeGroup
--   </pre>
clearShortcutsShortcutTitleSizeGroup :: (MonadIO m, IsShortcutsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsShortcutTitleSizeGroup :: (IsShortcutsShortcut o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>title-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsShortcut [ #titleSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsShortcutTitleSizeGroup :: (MonadIO m, IsShortcutsShortcut o, IsSizeGroup a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut o) => GI.Gtk.Objects.ShortcutsShortcut.IsShortcutsShortcut o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut


-- | A <tt>GtkShortcutsSection</tt> collects all the keyboard shortcuts and
--   gestures for a major application mode.
--   
--   If your application needs multiple sections, you should give each
--   section a unique <a>ShortcutsSection:sectionName</a> and a
--   <a>ShortcutsSection:title</a> that can be shown in the section
--   selector of the <a>ShortcutsWindow</a>.
--   
--   The <a>ShortcutsSection:maxHeight</a> property can be used to
--   influence how the groups in the section are distributed over pages and
--   columns.
--   
--   This widget is only meant to be used with <a>ShortcutsWindow</a>.
--   
--   The recommended way to construct a <tt>GtkShortcutsSection</tt> is
--   with <a>Builder</a>, by using the <tt>&lt;child&gt;</tt> tag to
--   populate a <tt>GtkShortcutsSection</tt> with one or more
--   <a>ShortcutsGroup</a> instances, which in turn contain one or more
--   <a>ShortcutsShortcut</a> objects.
--   
--   If you need to add a group programmatically, use
--   <a>shortcutsSectionAddGroup</a>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   Pan gestures allow to navigate between sections.
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>ShortcutsSection::changeCurrentPage</a></li>
--   </ul>
module GI.Gtk.Objects.ShortcutsSection

-- | Memory-managed wrapper type.
newtype ShortcutsSection
ShortcutsSection :: ManagedPtr ShortcutsSection -> ShortcutsSection

-- | Type class for types which can be safely cast to
--   <a>ShortcutsSection</a>, for instance with <a>toShortcutsSection</a>.
class (GObject o, IsDescendantOf ShortcutsSection o) => IsShortcutsSection o

-- | Cast to <a>ShortcutsSection</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toShortcutsSection :: (MonadIO m, IsShortcutsSection o) => o -> m ShortcutsSection

-- | Adds a group to the shortcuts section.
--   
--   This is the programmatic equivalent to using <a>Builder</a> and a
--   <tt>&lt;child&gt;</tt> tag to add the child.
--   
--   Adding children with the <tt>GtkBox</tt> API is not appropriate, as
--   <tt>GtkShortcutsSection</tt> manages its children internally.
--   
--   <i>Since: 4.14</i>

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutsSectionAddGroup :: (HasCallStack, MonadIO m, IsShortcutsSection a, IsShortcutsGroup b) => a -> b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-height</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsSectionMaxHeight :: (IsShortcutsSection o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #maxHeight
--   </pre>
getShortcutsSectionMaxHeight :: (MonadIO m, IsShortcutsSection o) => o -> m Word32

-- | Set the value of the “<tt>max-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #maxHeight <a>:=</a> value ]
--   </pre>
setShortcutsSectionMaxHeight :: (MonadIO m, IsShortcutsSection o) => o -> Word32 -> m ()

-- | Set the value of the “<tt>section-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #sectionName
--   </pre>
clearShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>section-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutsSectionSectionName :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #sectionName
--   </pre>
getShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>section-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #sectionName <a>:=</a> value ]
--   </pre>
setShortcutsSectionSectionName :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsSectionTitle :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #title
--   </pre>
getShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #title <a>:=</a> value ]
--   </pre>
setShortcutsSectionTitle :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Set the value of the “<tt>view-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #viewName
--   </pre>
clearShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>view-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutsSectionViewName :: (IsShortcutsSection o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsSection #viewName
--   </pre>
getShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>view-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsSection [ #viewName <a>:=</a> value ]
--   </pre>
setShortcutsSectionViewName :: (MonadIO m, IsShortcutsSection o) => o -> Text -> m ()

-- | Emitted when we change the current page.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt;,
--   &lt;kbd&gt;PgUp&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;,
--   &lt;kbd&gt;PgDn&lt;/kbd&gt;.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
type ShortcutsSectionChangeCurrentPageCallback = Int32 -> IO Bool

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> shortcutsSection #changeCurrentPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterShortcutsSectionChangeCurrentPage :: (IsShortcutsSection a, MonadIO m) => a -> ((?self :: a) => ShortcutsSectionChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> shortcutsSection #changeCurrentPage callback
--   </pre>
onShortcutsSectionChangeCurrentPage :: (IsShortcutsSection a, MonadIO m) => a -> ((?self :: a) => ShortcutsSectionChangeCurrentPageCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutsSection.ShortcutsSection
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutsSection.ShortcutsSection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutsSection.ShortcutsSection
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutsSection.ShortcutsSection)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutsSection.ShortcutsSection o) => GI.Gtk.Objects.ShortcutsSection.IsShortcutsSection o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutsSection.ShortcutsSection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutsSection.ShortcutsSection


-- | A <tt>GtkShortcutsGroup</tt> represents a group of related keyboard
--   shortcuts or gestures.
--   
--   The group has a title. It may optionally be associated with a view of
--   the application, which can be used to show only relevant shortcuts
--   depending on the application context.
--   
--   This widget is only meant to be used with <a>ShortcutsWindow</a>.
--   
--   The recommended way to construct a <tt>GtkShortcutsGroup</tt> is with
--   <a>Builder</a>, by using the <tt>&lt;child&gt;</tt> tag to populate a
--   <tt>GtkShortcutsGroup</tt> with one or more <a>ShortcutsShortcut</a>
--   instances.
--   
--   If you need to add a shortcut programmatically, use
--   <a>shortcutsGroupAddShortcut</a>.
module GI.Gtk.Objects.ShortcutsGroup

-- | Memory-managed wrapper type.
newtype ShortcutsGroup
ShortcutsGroup :: ManagedPtr ShortcutsGroup -> ShortcutsGroup

-- | Type class for types which can be safely cast to
--   <a>ShortcutsGroup</a>, for instance with <a>toShortcutsGroup</a>.
class (GObject o, IsDescendantOf ShortcutsGroup o) => IsShortcutsGroup o

-- | Cast to <a>ShortcutsGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toShortcutsGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ShortcutsGroup

-- | Adds a shortcut to the shortcuts group.
--   
--   This is the programmatic equivalent to using <a>Builder</a> and a
--   <tt>&lt;child&gt;</tt> tag to add the child. Adding children with
--   other API is not appropriate as <tt>GtkShortcutsGroup</tt> manages its
--   children internally.
--   
--   <i>Since: 4.14</i>

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutsGroupAddShortcut :: (HasCallStack, MonadIO m, IsShortcutsGroup a, IsShortcutsShortcut b) => a -> b -> m ()

-- | Set the value of the “<tt>accel-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #accelSizeGroup
--   </pre>
clearShortcutsGroupAccelSizeGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsGroupAccelSizeGroup :: (IsShortcutsGroup o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>accel-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #accelSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsGroupAccelSizeGroup :: (MonadIO m, IsShortcutsGroup o, IsSizeGroup a) => o -> a -> m ()

-- | Get the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsGroup #height
--   </pre>
getShortcutsGroupHeight :: (MonadIO m, IsShortcutsGroup o) => o -> m Word32

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsGroupTitle :: (IsShortcutsGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsGroup #title
--   </pre>
getShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #title <a>:=</a> value ]
--   </pre>
setShortcutsGroupTitle :: (MonadIO m, IsShortcutsGroup o) => o -> Text -> m ()

-- | Set the value of the “<tt>title-size-group</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #titleSizeGroup
--   </pre>
clearShortcutsGroupTitleSizeGroup :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title-size-group</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructShortcutsGroupTitleSizeGroup :: (IsShortcutsGroup o, MonadIO m, IsSizeGroup a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>title-size-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #titleSizeGroup <a>:=</a> value ]
--   </pre>
setShortcutsGroupTitleSizeGroup :: (MonadIO m, IsShortcutsGroup o, IsSizeGroup a) => o -> a -> m ()

-- | Set the value of the “<tt>view</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #view
--   </pre>
clearShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>view</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutsGroupView :: (IsShortcutsGroup o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>view</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutsGroup #view
--   </pre>
getShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>view</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutsGroup [ #view <a>:=</a> value ]
--   </pre>
setShortcutsGroupView :: (MonadIO m, IsShortcutsGroup o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutsGroup.ShortcutsGroup
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutsGroup.ShortcutsGroup
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutsGroup.ShortcutsGroup
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutsGroup.ShortcutsGroup)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutsGroup.ShortcutsGroup o) => GI.Gtk.Objects.ShortcutsGroup.IsShortcutsGroup o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutsGroup.ShortcutsGroup
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutsGroup.ShortcutsGroup


-- | <tt>GtkShortcutLabel</tt> displays a single keyboard shortcut or
--   gesture.
--   
--   The main use case for <tt>GtkShortcutLabel</tt> is inside a
--   <a>ShortcutsWindow</a>.
module GI.Gtk.Objects.ShortcutLabel

-- | Memory-managed wrapper type.
newtype ShortcutLabel
ShortcutLabel :: ManagedPtr ShortcutLabel -> ShortcutLabel

-- | Type class for types which can be safely cast to <a>ShortcutLabel</a>,
--   for instance with <a>toShortcutLabel</a>.
class (GObject o, IsDescendantOf ShortcutLabel o) => IsShortcutLabel o

-- | Cast to <a>ShortcutLabel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toShortcutLabel :: (MonadIO m, IsShortcutLabel o) => o -> m ShortcutLabel

-- | Retrieves the current accelerator of <i><tt>self</tt></i>.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutLabelGetAccelerator :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> m (Maybe Text)

-- | Retrieves the text that is displayed when no accelerator is set.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutLabelGetDisabledText :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> m (Maybe Text)

-- | Creates a new <tt>GtkShortcutLabel</tt> with
--   <i><tt>accelerator</tt></i> set.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutLabelNew :: (HasCallStack, MonadIO m) => Text -> m ShortcutLabel

-- | Sets the accelerator to be displayed by <i><tt>self</tt></i>.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutLabelSetAccelerator :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> Text -> m ()

-- | Sets the text to be displayed by <i><tt>self</tt></i> when no
--   accelerator is set.

-- | <i>Deprecated: (Since version 4.18)This widget will be removed in GTK
--   5</i>
shortcutLabelSetDisabledText :: (HasCallStack, MonadIO m, IsShortcutLabel a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accelerator</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutLabelAccelerator :: (IsShortcutLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutLabel #accelerator
--   </pre>
getShortcutLabelAccelerator :: (MonadIO m, IsShortcutLabel o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accelerator</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutLabel [ #accelerator <a>:=</a> value ]
--   </pre>
setShortcutLabelAccelerator :: (MonadIO m, IsShortcutLabel o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>disabled-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructShortcutLabelDisabledText :: (IsShortcutLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>disabled-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutLabel #disabledText
--   </pre>
getShortcutLabelDisabledText :: (MonadIO m, IsShortcutLabel o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>disabled-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutLabel [ #disabledText <a>:=</a> value ]
--   </pre>
setShortcutLabelDisabledText :: (MonadIO m, IsShortcutLabel o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutLabel.ShortcutLabel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutLabel.ShortcutLabel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutLabel.ShortcutLabel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutLabel.ShortcutLabel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutLabel.ShortcutLabel o) => GI.Gtk.Objects.ShortcutLabel.IsShortcutLabel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutLabel.ShortcutLabel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutLabel.ShortcutLabel


-- | Manages keyboard shortcuts and their activation.
--   
--   Most common shortcuts are using this controller implicitly, e.g. by
--   adding a mnemonic underline to a <a>Label</a>, or by installing a key
--   binding using <a>WidgetClass</a>.<tt><i>add_binding</i></tt>(), or by
--   adding accelerators to global actions using
--   <a>applicationSetAccelsForAction</a>.
--   
--   But it is possible to create your own shortcut controller, and add
--   shortcuts to it.
--   
--   <tt>GtkShortcutController</tt> implements <a>ListModel</a> for
--   querying the shortcuts that have been added to it.
--   
--   <h1>GtkShortcutController as GtkBuildable</h1>
--   
--   <tt>GtkShortcutController</tt>s can be created in <a>Builder</a> ui
--   files, to set up shortcuts in the same place as the widgets.
--   
--   An example of a UI definition fragment with
--   <tt>GtkShortcutController</tt>:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class='GtkButton'&gt;
--     &lt;child&gt;
--       &lt;object class='GtkShortcutController'&gt;
--         &lt;property name='scope'&gt;managed&lt;/property&gt;
--         &lt;child&gt;
--           &lt;object class='GtkShortcut'&gt;
--             &lt;property name='trigger'&gt;&amp;lt;Control&amp;gt;k&lt;/property&gt;
--             &lt;property name='action'&gt;activate&lt;/property&gt;
--           &lt;/object&gt;
--         &lt;/child&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   This example creates a <a>ActivateAction</a> for triggering the
--   <tt>activate</tt> signal of the <a>Button</a>. See
--   <a>shortcutActionParseString</a> for the syntax for other kinds of
--   <a>ShortcutAction</a>. See <a>shortcutTriggerParseString</a> to learn
--   more about the syntax for triggers.
module GI.Gtk.Objects.ShortcutController

-- | Memory-managed wrapper type.
newtype ShortcutController
ShortcutController :: ManagedPtr ShortcutController -> ShortcutController

-- | Type class for types which can be safely cast to
--   <a>ShortcutController</a>, for instance with
--   <a>toShortcutController</a>.
class (GObject o, IsDescendantOf ShortcutController o) => IsShortcutController o

-- | Cast to <a>ShortcutController</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toShortcutController :: (MonadIO m, IsShortcutController o) => o -> m ShortcutController

-- | Adds <i><tt>shortcut</tt></i> to the list of shortcuts handled by
--   <i><tt>self</tt></i>.
--   
--   If this controller uses an external shortcut list, this function does
--   nothing.
shortcutControllerAddShortcut :: (HasCallStack, MonadIO m, IsShortcutController a, IsShortcut b) => a -> b -> m ()

-- | Gets the mnemonics modifiers for when this controller activates its
--   shortcuts.
shortcutControllerGetMnemonicsModifiers :: (HasCallStack, MonadIO m, IsShortcutController a) => a -> m [ModifierType]

-- | Gets the scope for when this controller activates its shortcuts.
--   
--   See <a>shortcutControllerSetScope</a> for details.
shortcutControllerGetScope :: (HasCallStack, MonadIO m, IsShortcutController a) => a -> m ShortcutScope

-- | Creates a new shortcut controller.
shortcutControllerNew :: (HasCallStack, MonadIO m) => m ShortcutController

-- | Creates a new shortcut controller that takes its shortcuts from the
--   given list model.
--   
--   A controller created by this function does not let you add or remove
--   individual shortcuts using the shortcut controller api, but you can
--   change the contents of the model.
shortcutControllerNewForModel :: (HasCallStack, MonadIO m, IsListModel a) => a -> m ShortcutController

-- | Removes <i><tt>shortcut</tt></i> from the list of shortcuts handled by
--   <i><tt>self</tt></i>.
--   
--   If <i><tt>shortcut</tt></i> had not been added to
--   <i><tt>controller</tt></i> or this controller uses an external
--   shortcut list, this function does nothing.
shortcutControllerRemoveShortcut :: (HasCallStack, MonadIO m, IsShortcutController a, IsShortcut b) => a -> b -> m ()

-- | Sets the controller to use the given modifier for mnemonics.
--   
--   The mnemonics modifiers determines which modifiers need to be pressed
--   to allow activation of shortcuts with mnemonics triggers.
--   
--   GTK normally uses the Alt modifier for mnemonics, except in
--   <tt>GtkPopoverMenu</tt>s, where mnemonics can be triggered without any
--   modifiers. It should be very rarely necessary to change this, and
--   doing so is likely to interfere with other shortcuts.
--   
--   This value is only relevant for local shortcut controllers. Global and
--   managed shortcut controllers will have their shortcuts activated from
--   other places which have their own modifiers for activating mnemonics.
shortcutControllerSetMnemonicsModifiers :: (HasCallStack, MonadIO m, IsShortcutController a) => a -> [ModifierType] -> m ()

-- | Sets the controller to have the given <i><tt>scope</tt></i>.
--   
--   The scope allows shortcuts to be activated outside of the normal event
--   propagation. In particular, it allows installing global keyboard
--   shortcuts that can be activated even when a widget does not have
--   focus.
--   
--   With <a>ShortcutScopeLocal</a>, shortcuts will only be activated when
--   the widget has focus.
shortcutControllerSetScope :: (HasCallStack, MonadIO m, IsShortcutController a) => a -> ShortcutScope -> m ()

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutController #itemType
--   </pre>
getShortcutControllerItemType :: (MonadIO m, IsShortcutController o) => o -> m GType

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mnemonic-modifiers</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructShortcutControllerMnemonicModifiers :: (IsShortcutController o, MonadIO m) => [ModifierType] -> m (GValueConstruct o)

-- | Get the value of the “<tt>mnemonic-modifiers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutController #mnemonicModifiers
--   </pre>
getShortcutControllerMnemonicModifiers :: (MonadIO m, IsShortcutController o) => o -> m [ModifierType]

-- | Set the value of the “<tt>mnemonic-modifiers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutController [ #mnemonicModifiers <a>:=</a> value ]
--   </pre>
setShortcutControllerMnemonicModifiers :: (MonadIO m, IsShortcutController o) => o -> [ModifierType] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutControllerModel :: (IsShortcutController o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutController #nItems
--   </pre>
getShortcutControllerNItems :: (MonadIO m, IsShortcutController o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scope</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutControllerScope :: (IsShortcutController o, MonadIO m) => ShortcutScope -> m (GValueConstruct o)

-- | Get the value of the “<tt>scope</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcutController #scope
--   </pre>
getShortcutControllerScope :: (MonadIO m, IsShortcutController o) => o -> m ShortcutScope

-- | Set the value of the “<tt>scope</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcutController [ #scope <a>:=</a> value ]
--   </pre>
setShortcutControllerScope :: (MonadIO m, IsShortcutController o) => o -> ShortcutScope -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutController.ShortcutController
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutController.ShortcutController
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutController.ShortcutController
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutController.ShortcutController)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutController.ShortcutController o) => GI.Gtk.Objects.ShortcutController.IsShortcutController o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutController.ShortcutController
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutController.ShortcutController


-- | Encodes an action that can be triggered by a keyboard shortcut.
--   
--   <tt>GtkShortcutActions</tt> contain functions that allow easy
--   presentation to end users as well as being printed for debugging.
--   
--   All <tt>GtkShortcutActions</tt> are immutable, you can only specify
--   their properties during construction. If you want to change a action,
--   you have to replace it with a new one. If you need to pass arguments
--   to an action, these are specified by the higher-level
--   <tt>GtkShortcut</tt> object.
--   
--   To activate a <tt>GtkShortcutAction</tt> manually,
--   <a>shortcutActionActivate</a> can be called.
--   
--   GTK provides various actions:
--   
--   <ul>
--   <li><a>MnemonicAction</a>: a shortcut action that calls
--   <a>widgetMnemonicActivate</a></li>
--   <li><a>CallbackAction</a>: a shortcut action that invokes a given
--   callback</li>
--   <li><a>SignalAction</a>: a shortcut action that emits a given
--   signal</li>
--   <li><a>ActivateAction</a>: a shortcut action that calls
--   <a>widgetActivate</a></li>
--   <li><a>NamedAction</a>: a shortcut action that calls
--   <tt><i>gtk_widget_activate_action()</i></tt></li>
--   <li><a>NothingAction</a>: a shortcut action that does nothing</li>
--   </ul>
module GI.Gtk.Objects.ShortcutAction

-- | Memory-managed wrapper type.
newtype ShortcutAction
ShortcutAction :: ManagedPtr ShortcutAction -> ShortcutAction

-- | Type class for types which can be safely cast to
--   <a>ShortcutAction</a>, for instance with <a>toShortcutAction</a>.
class (GObject o, IsDescendantOf ShortcutAction o) => IsShortcutAction o

-- | Cast to <a>ShortcutAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toShortcutAction :: (MonadIO m, IsShortcutAction o) => o -> m ShortcutAction

-- | Activates the action on the <i><tt>widget</tt></i> with the given
--   <i><tt>args</tt></i>.
--   
--   Note that some actions ignore the passed in <i><tt>flags</tt></i>,
--   <i><tt>widget</tt></i> or <i><tt>args</tt></i>.
--   
--   Activation of an action can fail for various reasons. If the action is
--   not supported by the <i><tt>widget</tt></i>, if the
--   <i><tt>args</tt></i> don't match the action or if the activation
--   otherwise had no effect, <a>False</a> will be returned.
shortcutActionActivate :: (HasCallStack, MonadIO m, IsShortcutAction a, IsWidget b) => a -> [ShortcutActionFlags] -> b -> Maybe GVariant -> m Bool

-- | Tries to parse the given string into an action.
--   
--   On success, the parsed action is returned. When parsing failed,
--   <a>Nothing</a> is returned.
--   
--   The accepted strings are:
--   
--   <ul>
--   <li><tt>nothing</tt>, for <tt>GtkNothingAction</tt></li>
--   <li><tt>activate</tt>, for <tt>GtkActivateAction</tt></li>
--   <li><tt>mnemonic-activate</tt>, for <tt>GtkMnemonicAction</tt></li>
--   <li><tt>action(NAME)</tt>, for a <tt>GtkNamedAction</tt> for the
--   action named <tt>NAME</tt></li>
--   <li><tt>signal(NAME)</tt>, for a <tt>GtkSignalAction</tt> for the
--   signal <tt>NAME</tt></li>
--   </ul>
shortcutActionParseString :: (HasCallStack, MonadIO m) => Text -> m (Maybe ShortcutAction)

-- | Prints the given action into a string for the developer.
--   
--   This is meant for debugging and logging.
--   
--   The form of the representation may change at any time and is not
--   guaranteed to stay identical.
shortcutActionPrint :: (HasCallStack, MonadIO m, IsShortcutAction a) => a -> String -> m ()

-- | Prints the given action into a human-readable string.
--   
--   This is a small wrapper around <a>shortcutActionPrint</a> to help when
--   debugging.
shortcutActionToString :: (HasCallStack, MonadIO m, IsShortcutAction a) => a -> m Text
instance GHC.Classes.Eq GI.Gtk.Objects.ShortcutAction.ShortcutAction
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ShortcutAction.ShortcutAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ShortcutAction.ShortcutAction
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ShortcutAction.ShortcutAction)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ShortcutAction.ShortcutAction o) => GI.Gtk.Objects.ShortcutAction.IsShortcutAction o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ShortcutAction.ShortcutAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ShortcutAction.ShortcutAction


-- | Describes a keyboard shortcut.
--   
--   It contains a description of how to trigger the shortcut via a
--   <a>ShortcutTrigger</a> and a way to activate the shortcut on a widget
--   via a <a>ShortcutAction</a>.
--   
--   The actual work is usually done via <a>ShortcutController</a>, which
--   decides if and when to activate a shortcut. Using that controller
--   directly however is rarely necessary as various higher level
--   convenience APIs exist on <tt>GtkWidget</tt>s that make it easier to
--   use shortcuts in GTK.
--   
--   <tt>GtkShortcut</tt> does provide functionality to make it easy for
--   users to work with shortcuts, either by providing informational
--   strings for display purposes or by allowing shortcuts to be
--   configured.
module GI.Gtk.Objects.Shortcut

-- | Memory-managed wrapper type.
newtype Shortcut
Shortcut :: ManagedPtr Shortcut -> Shortcut

-- | Type class for types which can be safely cast to <a>Shortcut</a>, for
--   instance with <a>toShortcut</a>.
class (GObject o, IsDescendantOf Shortcut o) => IsShortcut o

-- | Cast to <a>Shortcut</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toShortcut :: (MonadIO m, IsShortcut o) => o -> m Shortcut

-- | Gets the action that is activated by this shortcut.
shortcutGetAction :: (HasCallStack, MonadIO m, IsShortcut a) => a -> m (Maybe ShortcutAction)

-- | Gets the arguments that are passed when activating the shortcut.
shortcutGetArguments :: (HasCallStack, MonadIO m, IsShortcut a) => a -> m (Maybe GVariant)

-- | Gets the trigger used to trigger <i><tt>self</tt></i>.
shortcutGetTrigger :: (HasCallStack, MonadIO m, IsShortcut a) => a -> m (Maybe ShortcutTrigger)

-- | Creates a new <tt>GtkShortcut</tt> that is triggered by
--   <i><tt>trigger</tt></i> and then activates <i><tt>action</tt></i>.
shortcutNew :: (HasCallStack, MonadIO m, IsShortcutTrigger a, IsShortcutAction b) => Maybe a -> Maybe b -> m Shortcut

-- | Sets the new action for <i><tt>self</tt></i> to be
--   <i><tt>action</tt></i>.
shortcutSetAction :: (HasCallStack, MonadIO m, IsShortcut a, IsShortcutAction b) => a -> Maybe b -> m ()

-- | Sets the arguments to pass when activating the shortcut.
shortcutSetArguments :: (HasCallStack, MonadIO m, IsShortcut a) => a -> Maybe GVariant -> m ()

-- | Sets the new trigger for <i><tt>self</tt></i> to be
--   <i><tt>trigger</tt></i>.
shortcutSetTrigger :: (HasCallStack, MonadIO m, IsShortcut a, IsShortcutTrigger b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>action</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #action
--   </pre>
clearShortcutAction :: (MonadIO m, IsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutAction :: (IsShortcut o, MonadIO m, IsShortcutAction a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcut #action
--   </pre>
getShortcutAction :: (MonadIO m, IsShortcut o) => o -> m (Maybe ShortcutAction)

-- | Set the value of the “<tt>action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcut [ #action <a>:=</a> value ]
--   </pre>
setShortcutAction :: (MonadIO m, IsShortcut o, IsShortcutAction a) => o -> a -> m ()

-- | Set the value of the “<tt>arguments</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #arguments
--   </pre>
clearShortcutArguments :: (MonadIO m, IsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>arguments</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructShortcutArguments :: (IsShortcut o, MonadIO m) => GVariant -> m (GValueConstruct o)

-- | Get the value of the “<tt>arguments</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcut #arguments
--   </pre>
getShortcutArguments :: (MonadIO m, IsShortcut o) => o -> m (Maybe GVariant)

-- | Set the value of the “<tt>arguments</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcut [ #arguments <a>:=</a> value ]
--   </pre>
setShortcutArguments :: (MonadIO m, IsShortcut o) => o -> GVariant -> m ()

-- | Set the value of the “<tt>trigger</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #trigger
--   </pre>
clearShortcutTrigger :: (MonadIO m, IsShortcut o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>trigger</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructShortcutTrigger :: (IsShortcut o, MonadIO m, IsShortcutTrigger a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>trigger</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shortcut #trigger
--   </pre>
getShortcutTrigger :: (MonadIO m, IsShortcut o) => o -> m (Maybe ShortcutTrigger)

-- | Set the value of the “<tt>trigger</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shortcut [ #trigger <a>:=</a> value ]
--   </pre>
setShortcutTrigger :: (MonadIO m, IsShortcut o, IsShortcutTrigger a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Shortcut.Shortcut
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Shortcut.Shortcut
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Shortcut.Shortcut
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Shortcut.Shortcut)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Shortcut.Shortcut o) => GI.Gtk.Objects.Shortcut.IsShortcut o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Shortcut.Shortcut
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Shortcut.Shortcut


-- | Draws a horizontal or vertical line to separate other widgets.
--   
--   &lt;picture&gt; &lt;source srcset="separator-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkSeparator" src="separator.png"&gt; &lt;/picture&gt;
--   
--   A <tt>GtkSeparator</tt> can be used to group the widgets within a
--   window. It displays a line with a shadow to make it appear sunken into
--   the interface.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkSeparator</tt> has a single CSS node with name separator. The
--   node gets one of the .horizontal or .vertical style classes.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkSeparator</tt> uses the <a>AccessibleRoleSeparator</a> role.
module GI.Gtk.Objects.Separator

-- | Memory-managed wrapper type.
newtype Separator
Separator :: ManagedPtr Separator -> Separator

-- | Type class for types which can be safely cast to <a>Separator</a>, for
--   instance with <a>toSeparator</a>.
class (GObject o, IsDescendantOf Separator o) => IsSeparator o

-- | Cast to <a>Separator</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSeparator :: (MonadIO m, IsSeparator o) => o -> m Separator

-- | Creates a new <tt>GtkSeparator</tt> with the given orientation.
separatorNew :: (HasCallStack, MonadIO m) => Orientation -> m Separator
instance GHC.Classes.Eq GI.Gtk.Objects.Separator.Separator
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Separator.Separator
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Separator.Separator
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Separator.Separator)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Separator.Separator o) => GI.Gtk.Objects.Separator.IsSeparator o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Separator.Separator
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Separator.Separator


-- | A single-line text entry widget for use as a search entry.
--   
--   The main API for interacting with a <tt>GtkSearchEntry</tt> as entry
--   is the <tt>GtkEditable</tt> interface.
--   
--   &lt;picture&gt; &lt;source srcset="search-entry-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkSearchEntry" src="search-entry.png"&gt; &lt;/picture&gt;
--   
--   It will show an inactive symbolic “find” icon when the search entry is
--   empty, and a symbolic “clear” icon when there is text. Clicking on the
--   “clear” icon will empty the search entry.
--   
--   To make filtering appear more reactive, it is a good idea to not react
--   to every change in the entry text immediately, but only after a short
--   delay. To support this, <tt>GtkSearchEntry</tt> emits the
--   <a>SearchEntry::searchChanged</a> signal which can be used instead of
--   the <a>Editable::changed</a> signal.
--   
--   The <a>SearchEntry::previousMatch</a>, <a>SearchEntry::nextMatch</a>
--   and <a>SearchEntry::stopSearch</a> signals can be used to implement
--   moving between search results and ending the search.
--   
--   Often, <tt>GtkSearchEntry</tt> will be fed events by means of being
--   placed inside a <a>SearchBar</a>. If that is not the case, you can use
--   <a>searchEntrySetKeyCaptureWidget</a> to let it capture key input from
--   another widget.
--   
--   <tt>GtkSearchEntry</tt> provides only minimal API and should be used
--   with the <a>Editable</a> API.
--   
--   <h2>Shortcuts and Gestures</h2>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>SearchEntry::activate</a></li>
--   <li><a>SearchEntry::nextMatch</a></li>
--   <li><a>SearchEntry::previousMatch</a></li>
--   <li><a>SearchEntry::stopSearch</a></li>
--   </ul>
--   
--   <h2>CSS Nodes</h2>
--   
--   <pre>
--   entry.search
--   ╰── text
--   </pre>
--   
--   <tt>GtkSearchEntry</tt> has a single CSS node with name entry that
--   carries a <tt>.search</tt> style class, and the text node is a child
--   of that.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkSearchEntry</tt> uses the <a>AccessibleRoleSearchBox</a> role.
module GI.Gtk.Objects.SearchEntry

-- | Memory-managed wrapper type.
newtype SearchEntry
SearchEntry :: ManagedPtr SearchEntry -> SearchEntry

-- | Type class for types which can be safely cast to <a>SearchEntry</a>,
--   for instance with <a>toSearchEntry</a>.
class (GObject o, IsDescendantOf SearchEntry o) => IsSearchEntry o

-- | Cast to <a>SearchEntry</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSearchEntry :: (MonadIO m, IsSearchEntry o) => o -> m SearchEntry

-- | Gets the input purpose for <i><tt>entry</tt></i>.
--   
--   <i>Since: 4.14</i>
searchEntryGetInputHints :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> m [InputHints]

-- | Gets the input purpose of <i><tt>entry</tt></i>.
--   
--   <i>Since: 4.14</i>
searchEntryGetInputPurpose :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> m InputPurpose

-- | Gets the widget that <i><tt>entry</tt></i> is capturing key events
--   from.
searchEntryGetKeyCaptureWidget :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> m (Maybe Widget)

-- | Gets the placeholder text associated with <i><tt>entry</tt></i>.
--   
--   <i>Since: 4.10</i>
searchEntryGetPlaceholderText :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> m (Maybe Text)

-- | Get the delay to be used between the last keypress and the
--   <a>SearchEntry::searchChanged</a> signal being emitted.
--   
--   <i>Since: 4.8</i>
searchEntryGetSearchDelay :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> m Word32

-- | Creates a <tt>GtkSearchEntry</tt>.
searchEntryNew :: (HasCallStack, MonadIO m) => m SearchEntry

-- | Sets the input hints for <i><tt>entry</tt></i>.
--   
--   <i>Since: 4.14</i>
searchEntrySetInputHints :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> [InputHints] -> m ()

-- | Sets the input purpose of <i><tt>entry</tt></i>.
--   
--   <i>Since: 4.14</i>
searchEntrySetInputPurpose :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> InputPurpose -> m ()

-- | Sets <i><tt>widget</tt></i> as the widget that <i><tt>entry</tt></i>
--   will capture key events from.
--   
--   Key events are consumed by the search entry to start or continue a
--   search.
--   
--   If the entry is part of a <tt>GtkSearchBar</tt>, it is preferable to
--   call <a>searchBarSetKeyCaptureWidget</a> instead, which will reveal
--   the entry in addition to triggering the search entry.
--   
--   Note that despite the name of this function, the events are only
--   'captured' in the bubble phase, which means that editable child
--   widgets of <i><tt>widget</tt></i> will receive text input before it
--   gets captured. If that is not desired, you can capture and forward the
--   events yourself with <a>eventControllerKeyForward</a>.
searchEntrySetKeyCaptureWidget :: (HasCallStack, MonadIO m, IsSearchEntry a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the placeholder text associated with <i><tt>entry</tt></i>.
--   
--   <i>Since: 4.10</i>
searchEntrySetPlaceholderText :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> Maybe Text -> m ()

-- | Set the delay to be used between the last keypress and the
--   <a>SearchEntry::searchChanged</a> signal being emitted.
--   
--   <i>Since: 4.8</i>
searchEntrySetSearchDelay :: (HasCallStack, MonadIO m, IsSearchEntry a) => a -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activates-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSearchEntryActivatesDefault :: (IsSearchEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchEntry #activatesDefault
--   </pre>
getSearchEntryActivatesDefault :: (MonadIO m, IsSearchEntry o) => o -> m Bool

-- | Set the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchEntry [ #activatesDefault <a>:=</a> value ]
--   </pre>
setSearchEntryActivatesDefault :: (MonadIO m, IsSearchEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSearchEntryInputHints :: (IsSearchEntry o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchEntry #inputHints
--   </pre>
getSearchEntryInputHints :: (MonadIO m, IsSearchEntry o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchEntry [ #inputHints <a>:=</a> value ]
--   </pre>
setSearchEntryInputHints :: (MonadIO m, IsSearchEntry o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSearchEntryInputPurpose :: (IsSearchEntry o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchEntry #inputPurpose
--   </pre>
getSearchEntryInputPurpose :: (MonadIO m, IsSearchEntry o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchEntry [ #inputPurpose <a>:=</a> value ]
--   </pre>
setSearchEntryInputPurpose :: (MonadIO m, IsSearchEntry o) => o -> InputPurpose -> m ()

-- | Set the value of the “<tt>key-capture-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #keyCaptureWidget
--   </pre>
clearSearchEntryKeyCaptureWidget :: (MonadIO m, IsSearchEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>key-capture-widget</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSearchEntryKeyCaptureWidget :: (IsSearchEntry o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>key-capture-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchEntry #keyCaptureWidget
--   </pre>
getSearchEntryKeyCaptureWidget :: (MonadIO m, IsSearchEntry o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>key-capture-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchEntry [ #keyCaptureWidget <a>:=</a> value ]
--   </pre>
setSearchEntryKeyCaptureWidget :: (MonadIO m, IsSearchEntry o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>placeholder-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #placeholderText
--   </pre>
clearSearchEntryPlaceholderText :: (MonadIO m, IsSearchEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>placeholder-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSearchEntryPlaceholderText :: (IsSearchEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchEntry #placeholderText
--   </pre>
getSearchEntryPlaceholderText :: (MonadIO m, IsSearchEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchEntry [ #placeholderText <a>:=</a> value ]
--   </pre>
setSearchEntryPlaceholderText :: (MonadIO m, IsSearchEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-delay</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSearchEntrySearchDelay :: (IsSearchEntry o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>search-delay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchEntry #searchDelay
--   </pre>
getSearchEntrySearchDelay :: (MonadIO m, IsSearchEntry o) => o -> m Word32

-- | Set the value of the “<tt>search-delay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchEntry [ #searchDelay <a>:=</a> value ]
--   </pre>
setSearchEntrySearchDelay :: (MonadIO m, IsSearchEntry o) => o -> Word32 -> m ()

-- | Emitted when the entry is activated.
--   
--   The keybindings for this signal are all forms of the
--   &lt;kbd&gt;Enter&lt;/kbd&gt; key.
type SearchEntryActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntryActivate :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #activate callback
--   </pre>
onSearchEntryActivate :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryActivateCallback) -> m SignalHandlerId

-- | Emitted when the user initiates a move to the next match for the
--   current search string.
--   
--   This is a <a>keybinding signal</a>.
--   
--   Applications should connect to it, to implement moving between
--   matches.
--   
--   The default bindings for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;g&lt;/kbd&gt;.
type SearchEntryNextMatchCallback = IO ()

-- | Connect a signal handler for the <a>nextMatch</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #nextMatch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntryNextMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryNextMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextMatch</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #nextMatch callback
--   </pre>
onSearchEntryNextMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryNextMatchCallback) -> m SignalHandlerId

-- | Emitted when the user initiates a move to the previous match for the
--   current search string.
--   
--   This is a <a>keybinding signal</a>.
--   
--   Applications should connect to it, to implement moving between
--   matches.
--   
--   The default bindings for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;g&lt;/kbd&gt;.
type SearchEntryPreviousMatchCallback = IO ()

-- | Connect a signal handler for the <a>previousMatch</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #previousMatch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntryPreviousMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryPreviousMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>previousMatch</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #previousMatch callback
--   </pre>
onSearchEntryPreviousMatch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryPreviousMatchCallback) -> m SignalHandlerId

-- | Emitted with a delay. The length of the delay can be changed with the
--   <a>SearchEntry:searchDelay</a> property.
type SearchEntrySearchChangedCallback = IO ()

-- | Connect a signal handler for the <a>searchChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #searchChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntrySearchChanged :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>searchChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #searchChanged callback
--   </pre>
onSearchEntrySearchChanged :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchChangedCallback) -> m SignalHandlerId

-- | Emitted when the user initiated a search on the entry.
type SearchEntrySearchStartedCallback = IO ()

-- | Connect a signal handler for the <a>searchStarted</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #searchStarted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntrySearchStarted :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchStartedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>searchStarted</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #searchStarted callback
--   </pre>
onSearchEntrySearchStarted :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntrySearchStartedCallback) -> m SignalHandlerId

-- | Emitted when the user stops a search via keyboard input.
--   
--   This is a <a>keybinding signal</a>.
--   
--   Applications should connect to it, to implement hiding the search
--   entry in this case.
--   
--   The default bindings for this signal is &lt;kbd&gt;Escape&lt;/kbd&gt;.
type SearchEntryStopSearchCallback = IO ()

-- | Connect a signal handler for the <a>stopSearch</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> searchEntry #stopSearch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSearchEntryStopSearch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryStopSearchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stopSearch</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> searchEntry #stopSearch callback
--   </pre>
onSearchEntryStopSearch :: (IsSearchEntry a, MonadIO m) => a -> ((?self :: a) => SearchEntryStopSearchCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.SearchEntry.SearchEntry
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SearchEntry.SearchEntry
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SearchEntry.SearchEntry
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SearchEntry.SearchEntry)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SearchEntry.SearchEntry o) => GI.Gtk.Objects.SearchEntry.IsSearchEntry o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SearchEntry.SearchEntry
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SearchEntry.SearchEntry


-- | Reveals a search entry when search is started.
--   
--   &lt;picture&gt; &lt;source srcset="search-bar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkSearchBar" src="search-bar.png"&gt; &lt;/picture&gt;
--   
--   It can also contain additional widgets, such as drop-down menus, or
--   buttons. The search bar would appear when a search is started through
--   typing on the keyboard, or the application’s search mode is toggled
--   on.
--   
--   For keyboard presses to start a search, the search bar must be told of
--   a widget to capture key events from through
--   <a>searchBarSetKeyCaptureWidget</a>. This widget will typically be the
--   top-level window, or a parent container of the search bar. Common
--   shortcuts such as Ctrl+F should be handled as an application action,
--   or through the menu items.
--   
--   You will also need to tell the search bar about which entry you are
--   using as your search entry using <a>searchBarConnectEntry</a>.
--   
--   <h2>Creating a search bar</h2>
--   
--   The following example shows you how to create a more complex search
--   entry.
--   
--   <a>A simple example</a>
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkSearchBar</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Escape&lt;/kbd&gt; hides the search bar.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   searchbar
--   ╰── revealer
--       ╰── box
--            ├── [child]
--            ╰── [button.close]
--   </pre>
--   
--   <tt>GtkSearchBar</tt> has a main CSS node with name searchbar. It has
--   a child node with name revealer that contains a node with name box.
--   The box node contains both the CSS node of the child widget as well as
--   an optional button node which gets the .close style class applied.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkSearchBar</tt> uses the <a>AccessibleRoleSearch</a> role.
module GI.Gtk.Objects.SearchBar

-- | Memory-managed wrapper type.
newtype SearchBar
SearchBar :: ManagedPtr SearchBar -> SearchBar

-- | Type class for types which can be safely cast to <a>SearchBar</a>, for
--   instance with <a>toSearchBar</a>.
class (GObject o, IsDescendantOf SearchBar o) => IsSearchBar o

-- | Cast to <a>SearchBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSearchBar :: (MonadIO m, IsSearchBar o) => o -> m SearchBar

-- | Connects the <tt>GtkEditable</tt> widget passed as the one to be used
--   in this search bar.
--   
--   The entry should be a descendant of the search bar. Calling this
--   function manually is only required if the entry isn’t the direct child
--   of the search bar (as in our main example).
searchBarConnectEntry :: (HasCallStack, MonadIO m, IsSearchBar a, IsEditable b) => a -> b -> m ()

-- | Gets the child widget of <i><tt>bar</tt></i>.
searchBarGetChild :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m (Maybe Widget)

-- | Gets the widget that <i><tt>bar</tt></i> is capturing key events from.
searchBarGetKeyCaptureWidget :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m (Maybe Widget)

-- | Returns whether the search mode is on or off.
searchBarGetSearchMode :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m Bool

-- | Returns whether the close button is shown.
searchBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> m Bool

-- | Creates a <tt>GtkSearchBar</tt>.
--   
--   You will need to tell it about which widget is going to be your text
--   entry using <a>searchBarConnectEntry</a>.
searchBarNew :: (HasCallStack, MonadIO m) => m SearchBar

-- | Sets the child widget of <i><tt>bar</tt></i>.
searchBarSetChild :: (HasCallStack, MonadIO m, IsSearchBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets <i><tt>widget</tt></i> as the widget that <i><tt>bar</tt></i>
--   will capture key events from.
--   
--   If key events are handled by the search bar, the bar will be shown,
--   and the entry populated with the entered text.
--   
--   Note that despite the name of this function, the events are only
--   'captured' in the bubble phase, which means that editable child
--   widgets of <i><tt>widget</tt></i> will receive text input before it
--   gets captured. If that is not desired, you can capture and forward the
--   events yourself with <a>eventControllerKeyForward</a>.
searchBarSetKeyCaptureWidget :: (HasCallStack, MonadIO m, IsSearchBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Switches the search mode on or off.
searchBarSetSearchMode :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> Bool -> m ()

-- | Shows or hides the close button.
--   
--   Applications that already have a “search” toggle button should not
--   show a close button in their search bar, as it duplicates the role of
--   the toggle button.
searchBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsSearchBar a) => a -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearSearchBarChild :: (MonadIO m, IsSearchBar o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSearchBarChild :: (IsSearchBar o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchBar #child
--   </pre>
getSearchBarChild :: (MonadIO m, IsSearchBar o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchBar [ #child <a>:=</a> value ]
--   </pre>
setSearchBarChild :: (MonadIO m, IsSearchBar o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>key-capture-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #keyCaptureWidget
--   </pre>
clearSearchBarKeyCaptureWidget :: (MonadIO m, IsSearchBar o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>key-capture-widget</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSearchBarKeyCaptureWidget :: (IsSearchBar o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>key-capture-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchBar #keyCaptureWidget
--   </pre>
getSearchBarKeyCaptureWidget :: (MonadIO m, IsSearchBar o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>key-capture-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchBar [ #keyCaptureWidget <a>:=</a> value ]
--   </pre>
setSearchBarKeyCaptureWidget :: (MonadIO m, IsSearchBar o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-mode-enabled</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructSearchBarSearchModeEnabled :: (IsSearchBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>search-mode-enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchBar #searchModeEnabled
--   </pre>
getSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> m Bool

-- | Set the value of the “<tt>search-mode-enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchBar [ #searchModeEnabled <a>:=</a> value ]
--   </pre>
setSearchBarSearchModeEnabled :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-close-button</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSearchBarShowCloseButton :: (IsSearchBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> searchBar #showCloseButton
--   </pre>
getSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> m Bool

-- | Set the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> searchBar [ #showCloseButton <a>:=</a> value ]
--   </pre>
setSearchBarShowCloseButton :: (MonadIO m, IsSearchBar o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.SearchBar.SearchBar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.SearchBar.SearchBar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.SearchBar.SearchBar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.SearchBar.SearchBar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.SearchBar.SearchBar o) => GI.Gtk.Objects.SearchBar.IsSearchBar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.SearchBar.SearchBar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.SearchBar.SearchBar


-- | Makes its child scrollable.
--   
--   &lt;picture&gt; &lt;source srcset="scrolledwindow-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkScrolledWindow" src="scrolledwindow.png"&gt; &lt;/picture&gt;
--   
--   It does so using either internally added scrollbars or externally
--   associated adjustments, and optionally draws a frame around the child.
--   
--   Widgets with native scrolling support, i.e. those whose classes
--   implement the <a>Scrollable</a> interface, are added directly. For
--   other types of widget, the class <a>Viewport</a> acts as an adaptor,
--   giving scrollability to other widgets. <a>scrolledWindowSetChild</a>
--   intelligently accounts for whether or not the added child is a
--   <tt>GtkScrollable</tt>. If it isn’t, then it wraps the child in a
--   <tt>GtkViewport</tt>. Therefore, you can just add any child widget and
--   not worry about the details.
--   
--   If <a>scrolledWindowSetChild</a> has added a <tt>GtkViewport</tt> for
--   you, it will be automatically removed when you unset the child. Unless
--   <a>ScrolledWindow:hscrollbarPolicy</a> and
--   <a>ScrolledWindow:vscrollbarPolicy</a> are <a>PolicyTypeNever</a> or
--   <a>PolicyTypeExternal</a>, <tt>GtkScrolledWindow</tt> adds internal
--   <tt>GtkScrollbar</tt> widgets around its child. The scroll position of
--   the child, and if applicable the scrollbars, is controlled by the
--   <a>ScrolledWindow:hadjustment</a> and
--   <a>ScrolledWindow:vadjustment</a> that are associated with the
--   <tt>GtkScrolledWindow</tt>. See the docs on <a>Scrollbar</a> for the
--   details, but note that the “step_increment” and “page_increment”
--   fields are only effective if the policy causes scrollbars to be
--   present.
--   
--   If a <tt>GtkScrolledWindow</tt> doesn’t behave quite as you would
--   like, or doesn’t have exactly the right layout, it’s very possible to
--   set up your own scrolling with <tt>GtkScrollbar</tt> and for example a
--   <tt>GtkGrid</tt>.
--   
--   <h1>Touch support</h1>
--   
--   <tt>GtkScrolledWindow</tt> has built-in support for touch devices.
--   When a touchscreen is used, swiping will move the scrolled window, and
--   will expose 'kinetic' behavior. This can be turned off with the
--   <a>ScrolledWindow:kineticScrolling</a> property if it is undesired.
--   
--   <tt>GtkScrolledWindow</tt> also displays visual 'overshoot' indication
--   when the content is pulled beyond the end, and this situation can be
--   captured with the <a>ScrolledWindow::edgeOvershot</a> signal.
--   
--   If no mouse device is present, the scrollbars will overlaid as narrow,
--   auto-hiding indicators over the content. If traditional scrollbars are
--   desired although no mouse is present, this behaviour can be turned off
--   with the <a>ScrolledWindow:overlayScrolling</a> property.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>ScrolledWindow::scrollChild</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkScrolledWindow</tt> has a main CSS node with name
--   scrolledwindow. It gets a .frame style class added when
--   <a>ScrolledWindow:hasFrame</a> is <a>True</a>.
--   
--   It uses subnodes with names overshoot and undershoot to draw the
--   overflow and underflow indications. These nodes get the .left, .right,
--   .top or .bottom style class added depending on where the indication is
--   drawn.
--   
--   <tt>GtkScrolledWindow</tt> also sets the positional style classes
--   (.left, .right, .top, .bottom) and style classes related to overlay
--   scrolling (.overlay-indicator, .dragging, .hovering) on its
--   scrollbars.
--   
--   If both scrollbars are visible, the area where they meet is drawn with
--   a subnode named junction.
--   
--   <h1>Accessibility</h1>
--   
--   Until GTK 4.10, <tt>GtkScrolledWindow</tt> used the
--   <a>AccessibleRoleGroup</a> role.
--   
--   Starting from GTK 4.12, <tt>GtkScrolledWindow</tt> uses the
--   <a>AccessibleRoleGeneric</a> role.
module GI.Gtk.Objects.ScrolledWindow

-- | Memory-managed wrapper type.
newtype ScrolledWindow
ScrolledWindow :: ManagedPtr ScrolledWindow -> ScrolledWindow

-- | Type class for types which can be safely cast to
--   <a>ScrolledWindow</a>, for instance with <a>toScrolledWindow</a>.
class (GObject o, IsDescendantOf ScrolledWindow o) => IsScrolledWindow o

-- | Cast to <a>ScrolledWindow</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScrolledWindow :: (MonadIO m, IsScrolledWindow o) => o -> m ScrolledWindow

-- | Gets the child widget of <i><tt>scrolledWindow</tt></i>.
--   
--   If the scrolled window automatically added a <a>Viewport</a>, this
--   function will return the viewport widget, and you can retrieve its
--   child using <a>viewportGetChild</a>.
scrolledWindowGetChild :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m (Maybe Widget)

-- | Returns the horizontal scrollbar’s adjustment.
--   
--   This is the adjustment used to connect the horizontal scrollbar to the
--   child widget’s horizontal scroll functionality.
scrolledWindowGetHadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Adjustment

-- | Gets whether the scrolled window draws a frame.
scrolledWindowGetHasFrame :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Returns the horizontal scrollbar of <i><tt>scrolledWindow</tt></i>.
scrolledWindowGetHscrollbar :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Widget

-- | Returns the specified kinetic scrolling behavior.
scrolledWindowGetKineticScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Returns the maximum content height set.
scrolledWindowGetMaxContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Returns the maximum content width set.
scrolledWindowGetMaxContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Gets the minimal content height of <i><tt>scrolledWindow</tt></i>.
scrolledWindowGetMinContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Gets the minimum content width of <i><tt>scrolledWindow</tt></i>.
scrolledWindowGetMinContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Int32

-- | Returns whether overlay scrolling is enabled for this scrolled window.
scrolledWindowGetOverlayScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Gets the placement of the contents with respect to the scrollbars.
scrolledWindowGetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m CornerType

-- | Retrieves the current policy values for the horizontal and vertical
--   scrollbars.
--   
--   See <a>scrolledWindowSetPolicy</a>.
scrolledWindowGetPolicy :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m (PolicyType, PolicyType)

-- | Reports whether the natural height of the child will be calculated and
--   propagated through the scrolled window’s requested natural height.
scrolledWindowGetPropagateNaturalHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Reports whether the natural width of the child will be calculated and
--   propagated through the scrolled window’s requested natural width.
scrolledWindowGetPropagateNaturalWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Bool

-- | Returns the vertical scrollbar’s adjustment.
--   
--   This is the adjustment used to connect the vertical scrollbar to the
--   child widget’s vertical scroll functionality.
scrolledWindowGetVadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Adjustment

-- | Returns the vertical scrollbar of <i><tt>scrolledWindow</tt></i>.
scrolledWindowGetVscrollbar :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m Widget

-- | Creates a new scrolled window.
scrolledWindowNew :: (HasCallStack, MonadIO m) => m ScrolledWindow

-- | Sets the child widget of <i><tt>scrolledWindow</tt></i>.
--   
--   If <i><tt>child</tt></i> does not implement the <a>Scrollable</a>
--   interface, the scrolled window will add <i><tt>child</tt></i> to a
--   <a>Viewport</a> instance and then add the viewport as its child
--   widget.
scrolledWindowSetChild :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkAdjustment</tt> for the horizontal scrollbar.
scrolledWindowSetHadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Changes the frame drawn around the contents of
--   <i><tt>scrolledWindow</tt></i>.
scrolledWindowSetHasFrame :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Turns kinetic scrolling on or off.
--   
--   Kinetic scrolling only applies to devices with source
--   <a>InputSourceTouchscreen</a>.
scrolledWindowSetKineticScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the maximum height that <i><tt>scrolledWindow</tt></i> should
--   keep visible.
--   
--   The <i><tt>scrolledWindow</tt></i> will grow up to this height before
--   it starts scrolling the content.
--   
--   It is a programming error to set the maximum content height to a value
--   smaller than <a>ScrolledWindow:minContentHeight</a>.
scrolledWindowSetMaxContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the maximum width that <i><tt>scrolledWindow</tt></i> should keep
--   visible.
--   
--   The <i><tt>scrolledWindow</tt></i> will grow up to this width before
--   it starts scrolling the content.
--   
--   It is a programming error to set the maximum content width to a value
--   smaller than <a>ScrolledWindow:minContentWidth</a>.
scrolledWindowSetMaxContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the minimum height that <i><tt>scrolledWindow</tt></i> should
--   keep visible.
--   
--   Note that this can and (usually will) be smaller than the minimum size
--   of the content.
--   
--   It is a programming error to set the minimum content height to a value
--   greater than <a>ScrolledWindow:maxContentHeight</a>.
scrolledWindowSetMinContentHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Sets the minimum width that <i><tt>scrolledWindow</tt></i> should keep
--   visible.
--   
--   Note that this can and (usually will) be smaller than the minimum size
--   of the content.
--   
--   It is a programming error to set the minimum content width to a value
--   greater than <a>ScrolledWindow:maxContentWidth</a>.
scrolledWindowSetMinContentWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Int32 -> m ()

-- | Enables or disables overlay scrolling for this scrolled window.
scrolledWindowSetOverlayScrolling :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the placement of the contents with respect to the scrollbars for
--   the scrolled window.
--   
--   The default is <a>CornerTypeTopLeft</a>, meaning the child is in the
--   top left, with the scrollbars underneath and to the right. Other
--   values in <a>CornerType</a> are <a>CornerTypeTopRight</a>,
--   <a>CornerTypeBottomLeft</a>, and <a>CornerTypeBottomRight</a>.
--   
--   See also <a>scrolledWindowGetPlacement</a> and
--   <a>scrolledWindowUnsetPlacement</a>.
scrolledWindowSetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> CornerType -> m ()

-- | Sets the scrollbar policy for the horizontal and vertical scrollbars.
--   
--   The policy determines when the scrollbar should appear; it is a value
--   from the <a>PolicyType</a> enumeration. If <a>PolicyTypeAlways</a>,
--   the scrollbar is always present; if <a>PolicyTypeNever</a>, the
--   scrollbar is never present; if <a>PolicyTypeAutomatic</a>, the
--   scrollbar is present only if needed (that is, if the slider part of
--   the bar would be smaller than the trough — the display is larger than
--   the page size).
scrolledWindowSetPolicy :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> PolicyType -> PolicyType -> m ()

-- | Sets whether the natural height of the child should be calculated and
--   propagated through the scrolled window’s requested natural height.
scrolledWindowSetPropagateNaturalHeight :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets whether the natural width of the child should be calculated and
--   propagated through the scrolled window’s requested natural width.
scrolledWindowSetPropagateNaturalWidth :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> Bool -> m ()

-- | Sets the <tt>GtkAdjustment</tt> for the vertical scrollbar.
scrolledWindowSetVadjustment :: (HasCallStack, MonadIO m, IsScrolledWindow a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Unsets the placement of the contents with respect to the scrollbars.
--   
--   If no window placement is set for a scrolled window, it defaults to
--   <a>CornerTypeTopLeft</a>.
scrolledWindowUnsetPlacement :: (HasCallStack, MonadIO m, IsScrolledWindow a) => a -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearScrolledWindowChild :: (MonadIO m, IsScrolledWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScrolledWindowChild :: (IsScrolledWindow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #child
--   </pre>
getScrolledWindowChild :: (MonadIO m, IsScrolledWindow o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #child <a>:=</a> value ]
--   </pre>
setScrolledWindowChild :: (MonadIO m, IsScrolledWindow o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>hadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #hadjustment
--   </pre>
clearScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrolledWindowHadjustment :: (IsScrolledWindow o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #hadjustment
--   </pre>
getScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Adjustment

-- | Set the value of the “<tt>hadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #hadjustment <a>:=</a> value ]
--   </pre>
setScrolledWindowHadjustment :: (MonadIO m, IsScrolledWindow o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScrolledWindowHasFrame :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #hasFrame
--   </pre>
getScrolledWindowHasFrame :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #hasFrame <a>:=</a> value ]
--   </pre>
setScrolledWindowHasFrame :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>hscrollbar-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowHscrollbarPolicy :: (IsScrolledWindow o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “<tt>hscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #hscrollbarPolicy
--   </pre>
getScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m PolicyType

-- | Set the value of the “<tt>hscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #hscrollbarPolicy <a>:=</a> value ]
--   </pre>
setScrolledWindowHscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> PolicyType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>kinetic-scrolling</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowKineticScrolling :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>kinetic-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #kineticScrolling
--   </pre>
getScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>kinetic-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #kineticScrolling <a>:=</a> value ]
--   </pre>
setScrolledWindowKineticScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-content-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowMaxContentHeight :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #maxContentHeight
--   </pre>
getScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>max-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #maxContentHeight <a>:=</a> value ]
--   </pre>
setScrolledWindowMaxContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-content-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowMaxContentWidth :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #maxContentWidth
--   </pre>
getScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>max-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #maxContentWidth <a>:=</a> value ]
--   </pre>
setScrolledWindowMaxContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-content-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowMinContentHeight :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #minContentHeight
--   </pre>
getScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>min-content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #minContentHeight <a>:=</a> value ]
--   </pre>
setScrolledWindowMinContentHeight :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-content-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowMinContentWidth :: (IsScrolledWindow o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #minContentWidth
--   </pre>
getScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Int32

-- | Set the value of the “<tt>min-content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #minContentWidth <a>:=</a> value ]
--   </pre>
setScrolledWindowMinContentWidth :: (MonadIO m, IsScrolledWindow o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overlay-scrolling</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowOverlayScrolling :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #overlayScrolling
--   </pre>
getScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>overlay-scrolling</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #overlayScrolling <a>:=</a> value ]
--   </pre>
setScrolledWindowOverlayScrolling :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagate-natural-height</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowPropagateNaturalHeight :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>propagate-natural-height</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #propagateNaturalHeight
--   </pre>
getScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>propagate-natural-height</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #propagateNaturalHeight <a>:=</a> value ]
--   </pre>
setScrolledWindowPropagateNaturalHeight :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagate-natural-width</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructScrolledWindowPropagateNaturalWidth :: (IsScrolledWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>propagate-natural-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #propagateNaturalWidth
--   </pre>
getScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> m Bool

-- | Set the value of the “<tt>propagate-natural-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #propagateNaturalWidth <a>:=</a> value ]
--   </pre>
setScrolledWindowPropagateNaturalWidth :: (MonadIO m, IsScrolledWindow o) => o -> Bool -> m ()

-- | Set the value of the “<tt>vadjustment</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #vadjustment
--   </pre>
clearScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vadjustment</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructScrolledWindowVadjustment :: (IsScrolledWindow o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #vadjustment
--   </pre>
getScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o) => o -> m Adjustment

-- | Set the value of the “<tt>vadjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #vadjustment <a>:=</a> value ]
--   </pre>
setScrolledWindowVadjustment :: (MonadIO m, IsScrolledWindow o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>vscrollbar-policy</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowVscrollbarPolicy :: (IsScrolledWindow o, MonadIO m) => PolicyType -> m (GValueConstruct o)

-- | Get the value of the “<tt>vscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #vscrollbarPolicy
--   </pre>
getScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> m PolicyType

-- | Set the value of the “<tt>vscrollbar-policy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #vscrollbarPolicy <a>:=</a> value ]
--   </pre>
setScrolledWindowVscrollbarPolicy :: (MonadIO m, IsScrolledWindow o) => o -> PolicyType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>window-placement</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructScrolledWindowWindowPlacement :: (IsScrolledWindow o, MonadIO m) => CornerType -> m (GValueConstruct o)

-- | Get the value of the “<tt>window-placement</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrolledWindow #windowPlacement
--   </pre>
getScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> m CornerType

-- | Set the value of the “<tt>window-placement</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrolledWindow [ #windowPlacement <a>:=</a> value ]
--   </pre>
setScrolledWindowWindowPlacement :: (MonadIO m, IsScrolledWindow o) => o -> CornerType -> m ()

-- | Emitted whenever user initiated scrolling makes the scrolled window
--   firmly surpass the limits defined by the adjustment in that
--   orientation.
--   
--   A similar behavior without edge resistance is provided by the
--   <a>ScrolledWindow::edgeReached</a> signal.
--   
--   Note: The <i><tt>pos</tt></i> argument is LTR/RTL aware, so callers
--   should be aware too if intending to provide behavior on horizontal
--   edges.
type ScrolledWindowEdgeOvershotCallback = PositionType -> IO ()

-- | Connect a signal handler for the <a>edgeOvershot</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #edgeOvershot callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeOvershotCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>edgeOvershot</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #edgeOvershot callback
--   </pre>
onScrolledWindowEdgeOvershot :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeOvershotCallback) -> m SignalHandlerId

-- | Emitted whenever user-initiated scrolling makes the scrolled window
--   exactly reach the lower or upper limits defined by the adjustment in
--   that orientation.
--   
--   A similar behavior with edge resistance is provided by the
--   <a>ScrolledWindow::edgeOvershot</a> signal.
--   
--   Note: The <i><tt>pos</tt></i> argument is LTR/RTL aware, so callers
--   should be aware too if intending to provide behavior on horizontal
--   edges.
type ScrolledWindowEdgeReachedCallback = PositionType -> IO ()

-- | Connect a signal handler for the <a>edgeReached</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #edgeReached callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeReachedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>edgeReached</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #edgeReached callback
--   </pre>
onScrolledWindowEdgeReached :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowEdgeReachedCallback) -> m SignalHandlerId

-- | Emitted when focus is moved away from the scrolled window by a
--   keybinding.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; to move forward
--   and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt;`
--   to move backward.
type ScrolledWindowMoveFocusOutCallback = DirectionType -> IO ()

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #moveFocusOut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #moveFocusOut callback
--   </pre>
onScrolledWindowMoveFocusOut :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowMoveFocusOutCallback) -> m SignalHandlerId

-- | Emitted when a keybinding that scrolls is pressed.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The horizontal or vertical adjustment is updated which triggers a
--   signal that the scrolled window’s child may listen to and scroll
--   itself.
type ScrolledWindowScrollChildCallback = ScrollType -> Bool -> IO Bool

-- | Connect a signal handler for the <a>scrollChild</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scrolledWindow #scrollChild callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowScrollChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollChild</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scrolledWindow #scrollChild callback
--   </pre>
onScrolledWindowScrollChild :: (IsScrolledWindow a, MonadIO m) => a -> ((?self :: a) => ScrolledWindowScrollChildCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ScrolledWindow.ScrolledWindow
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ScrolledWindow.ScrolledWindow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ScrolledWindow.ScrolledWindow
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ScrolledWindow.ScrolledWindow)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ScrolledWindow.ScrolledWindow o) => GI.Gtk.Objects.ScrolledWindow.IsScrolledWindow o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ScrolledWindow.ScrolledWindow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ScrolledWindow.ScrolledWindow


-- | Shows a horizontal or vertical scrollbar.
--   
--   &lt;picture&gt; &lt;source srcset="scrollbar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkScrollbar" src="scrollbar.png"&gt; &lt;/picture&gt;
--   
--   Its position and movement are controlled by the adjustment that is
--   passed to or created by <a>scrollbarNew</a>. See <a>Adjustment</a> for
--   more details. The <a>Adjustment:value</a> field sets the position of
--   the thumb and must be between <a>Adjustment:lower</a> and
--   <a>Adjustment:upper</a> - <a>Adjustment:pageSize</a>. The
--   <a>Adjustment:pageSize</a> represents the size of the visible
--   scrollable area.
--   
--   The fields <a>Adjustment:stepIncrement</a> and
--   <a>Adjustment:pageIncrement</a> fields are added to or subtracted from
--   the <a>Adjustment:value</a> when the user asks to move by a step
--   (using e.g. the cursor arrow keys) or by a page (using e.g. the Page
--   Down/Up keys).
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   scrollbar
--   ╰── range[.fine-tune]
--       ╰── trough
--           ╰── slider
--   </pre>
--   
--   <tt>GtkScrollbar</tt> has a main CSS node with name scrollbar and a
--   subnode for its contents. The main node gets the .horizontal or
--   .vertical style classes applied, depending on the scrollbar's
--   orientation.
--   
--   The range node gets the style class .fine-tune added when the
--   scrollbar is in 'fine-tuning' mode.
--   
--   Other style classes that may be added to scrollbars inside
--   <a>ScrolledWindow</a> include the positional classes (.left, .right,
--   .top, .bottom) and style classes related to overlay scrolling
--   (.overlay-indicator, .dragging, .hovering).
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkScrollbar</tt> uses the <a>AccessibleRoleScrollbar</a> role.
module GI.Gtk.Objects.Scrollbar

-- | Memory-managed wrapper type.
newtype Scrollbar
Scrollbar :: ManagedPtr Scrollbar -> Scrollbar

-- | Type class for types which can be safely cast to <a>Scrollbar</a>, for
--   instance with <a>toScrollbar</a>.
class (GObject o, IsDescendantOf Scrollbar o) => IsScrollbar o

-- | Cast to <a>Scrollbar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScrollbar :: (MonadIO m, IsScrollbar o) => o -> m Scrollbar

-- | Returns the scrollbar's adjustment.
scrollbarGetAdjustment :: (HasCallStack, MonadIO m, IsScrollbar a) => a -> m Adjustment

-- | Creates a new scrollbar with the given orientation.
scrollbarNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe a -> m Scrollbar

-- | Makes the scrollbar use the given adjustment.
scrollbarSetAdjustment :: (HasCallStack, MonadIO m, IsScrollbar a, IsAdjustment b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>adjustment</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #adjustment
--   </pre>
clearScrollbarAdjustment :: (MonadIO m, IsScrollbar o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScrollbarAdjustment :: (IsScrollbar o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scrollbar #adjustment
--   </pre>
getScrollbarAdjustment :: (MonadIO m, IsScrollbar o) => o -> m Adjustment

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scrollbar [ #adjustment <a>:=</a> value ]
--   </pre>
setScrollbarAdjustment :: (MonadIO m, IsScrollbar o, IsAdjustment a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Scrollbar.Scrollbar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Scrollbar.Scrollbar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Scrollbar.Scrollbar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Scrollbar.Scrollbar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Scrollbar.Scrollbar o) => GI.Gtk.Objects.Scrollbar.IsScrollbar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Scrollbar.Scrollbar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Scrollbar.Scrollbar


-- | Provides a button which pops up a scale widget.
--   
--   This kind of widget is commonly used for volume controls in multimedia
--   applications, and GTK provides a <a>VolumeButton</a> subclass that is
--   tailored for this use case.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>ScaleButton::popup</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   scalebutton.scale
--   ╰── button.toggle
--       ╰── &lt;icon&gt;
--   </pre>
--   
--   <tt>GtkScaleButton</tt> has a single CSS node with name scalebutton
--   and <tt>.scale</tt> style class, and contains a <tt>button</tt> node
--   with a <tt>.toggle</tt> style class.
module GI.Gtk.Objects.ScaleButton

-- | Memory-managed wrapper type.
newtype ScaleButton
ScaleButton :: ManagedPtr ScaleButton -> ScaleButton

-- | Type class for types which can be safely cast to <a>ScaleButton</a>,
--   for instance with <a>toScaleButton</a>.
class (GObject o, IsDescendantOf ScaleButton o) => IsScaleButton o

-- | Cast to <a>ScaleButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toScaleButton :: (MonadIO m, IsScaleButton o) => o -> m ScaleButton

-- | Queries a <tt>GtkScaleButton</tt> and returns its current state.
--   
--   Returns <a>True</a> if the scale button is pressed in and <a>False</a>
--   if it is raised.
--   
--   <i>Since: 4.10</i>
scaleButtonGetActive :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Bool

-- | Gets the <tt>GtkAdjustment</tt> associated with the
--   <tt>GtkScaleButton</tt>’s scale.
--   
--   See <a>rangeGetAdjustment</a> for details.
scaleButtonGetAdjustment :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Adjustment

-- | Returns whether the button has a frame.
--   
--   <i>Since: 4.14</i>
scaleButtonGetHasFrame :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Bool

-- | Retrieves the minus button of the <tt>GtkScaleButton</tt>.
scaleButtonGetMinusButton :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Button

-- | Retrieves the plus button of the <tt>GtkScaleButton.</tt>
scaleButtonGetPlusButton :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Button

-- | Retrieves the popup of the <tt>GtkScaleButton</tt>.
scaleButtonGetPopup :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Widget

-- | Gets the current value of the scale button.
scaleButtonGetValue :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> m Double

-- | Creates a <tt>GtkScaleButton</tt>.
--   
--   The new scale button has a range between <i><tt>min</tt></i> and
--   <i><tt>max</tt></i>, with a stepping of <i><tt>step</tt></i>.
scaleButtonNew :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> Maybe [Text] -> m ScaleButton

-- | Sets the <tt>GtkAdjustment</tt> to be used as a model for the
--   <tt>GtkScaleButton</tt>’s scale.
--   
--   See <a>rangeSetAdjustment</a> for details.
scaleButtonSetAdjustment :: (HasCallStack, MonadIO m, IsScaleButton a, IsAdjustment b) => a -> b -> m ()

-- | Sets the style of the button.
--   
--   <i>Since: 4.14</i>
scaleButtonSetHasFrame :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> Bool -> m ()

-- | Sets the icons to be used by the scale button.
scaleButtonSetIcons :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> [Text] -> m ()

-- | Sets the current value of the scale.
--   
--   If the value is outside the minimum or maximum range values, it will
--   be clamped to fit inside them.
--   
--   The scale button emits the <a>ScaleButton::valueChanged</a> signal if
--   the value changes.
scaleButtonSetValue :: (HasCallStack, MonadIO m, IsScaleButton a) => a -> Double -> m ()

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #active
--   </pre>
getScaleButtonActive :: (MonadIO m, IsScaleButton o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleButtonAdjustment :: (IsScaleButton o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #adjustment
--   </pre>
getScaleButtonAdjustment :: (MonadIO m, IsScaleButton o) => o -> m Adjustment

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #adjustment <a>:=</a> value ]
--   </pre>
setScaleButtonAdjustment :: (MonadIO m, IsScaleButton o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleButtonHasFrame :: (IsScaleButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #hasFrame
--   </pre>
getScaleButtonHasFrame :: (MonadIO m, IsScaleButton o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #hasFrame <a>:=</a> value ]
--   </pre>
setScaleButtonHasFrame :: (MonadIO m, IsScaleButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icons</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScaleButtonIcons :: (IsScaleButton o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>icons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #icons
--   </pre>
getScaleButtonIcons :: (MonadIO m, IsScaleButton o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>icons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #icons <a>:=</a> value ]
--   </pre>
setScaleButtonIcons :: (MonadIO m, IsScaleButton o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScaleButtonValue :: (IsScaleButton o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scaleButton #value
--   </pre>
getScaleButtonValue :: (MonadIO m, IsScaleButton o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scaleButton [ #value <a>:=</a> value ]
--   </pre>
setScaleButtonValue :: (MonadIO m, IsScaleButton o) => o -> Double -> m ()

-- | Emitted to dismiss the popup.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;Escape&lt;/kbd&gt;.
type ScaleButtonPopdownCallback = IO ()

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scaleButton #popdown callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScaleButtonPopdown :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scaleButton #popdown callback
--   </pre>
onScaleButtonPopdown :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopdownCallback) -> m SignalHandlerId

-- | Emitted to popup the scale widget.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are &lt;kbd&gt;Space&lt;/kbd&gt;,
--   &lt;kbd&gt;Enter&lt;/kbd&gt; and &lt;kbd&gt;Return&lt;/kbd&gt;.
type ScaleButtonPopupCallback = IO ()

-- | Connect a signal handler for the <a>popup</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scaleButton #popup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScaleButtonPopup :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popup</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> scaleButton #popup callback
--   </pre>
onScaleButtonPopup :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonPopupCallback) -> m SignalHandlerId

-- | Emitted when the value field has changed.
type ScaleButtonValueChangedCallback = Double -> IO ()

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> scaleButton #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterScaleButtonValueChanged :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> scaleButton #valueChanged callback
--   </pre>
onScaleButtonValueChanged :: (IsScaleButton a, MonadIO m) => a -> ((?self :: a) => ScaleButtonValueChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ScaleButton.ScaleButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ScaleButton.ScaleButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ScaleButton.ScaleButton
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ScaleButton.ScaleButton)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ScaleButton.ScaleButton o) => GI.Gtk.Objects.ScaleButton.IsScaleButton o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ScaleButton.ScaleButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ScaleButton.ScaleButton


-- | Allows to select a numeric value with a slider control.
--   
--   &lt;picture&gt; &lt;source srcset="scales-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkScale" src="scales.png"&gt; &lt;/picture&gt;
--   
--   To use it, you’ll probably want to investigate the methods on its base
--   class, <a>Range</a>, in addition to the methods for <tt>GtkScale</tt>
--   itself. To set the value of a scale, you would normally use
--   <a>rangeSetValue</a>. To detect changes to the value, you would
--   normally use the <a>Range::valueChanged</a> signal.
--   
--   Note that using the same upper and lower bounds for the
--   <tt>GtkScale</tt> (through the <tt>GtkRange</tt> methods) will hide
--   the slider itself. This is useful for applications that want to show
--   an undeterminate value on the scale, without changing the layout of
--   the application (such as movie or music players).
--   
--   <h1>GtkScale as GtkBuildable</h1>
--   
--   <tt>GtkScale</tt> supports a custom <tt>&lt;marks&gt;</tt> element,
--   which can contain multiple <tt>&lt;mark\&gt;</tt> elements. The
--   “value” and “position” attributes have the same meaning as
--   <a>scaleAddMark</a> parameters of the same name. If the element is not
--   empty, its content is taken as the markup to show at the mark. It can
--   be translated with the usual ”translatable” and “context” attributes.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkPopoverMenu</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>Arrow keys, &lt;kbd&gt;+&lt;/kbd&gt; and &lt;kbd&gt;-&lt;/kbd&gt;
--   will increment or decrement by step, or by page when combined with
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;.</li>
--   <li>&lt;kbd&gt;PgUp&lt;/kbd&gt; and &lt;kbd&gt;PgDn&lt;/kbd&gt; will
--   increment or decrement by page.</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt; and &lt;kbd&gt;End&lt;/kbd&gt; will
--   set the minimum or maximum value.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   scale[.fine-tune][.marks-before][.marks-after]
--   ├── [value][.top][.right][.bottom][.left]
--   ├── marks.top
--   │   ├── mark
--   │   ┊    ├── [label]
--   │   ┊    ╰── indicator
--   ┊   ┊
--   │   ╰── mark
--   ├── marks.bottom
--   │   ├── mark
--   │   ┊    ├── indicator
--   │   ┊    ╰── [label]
--   ┊   ┊
--   │   ╰── mark
--   ╰── trough
--       ├── [fill]
--       ├── [highlight]
--       ╰── slider
--   </pre>
--   
--   <tt>GtkScale</tt> has a main CSS node with name scale and a subnode
--   for its contents, with subnodes named trough and slider.
--   
--   The main node gets the style class .fine-tune added when the scale is
--   in 'fine-tuning' mode.
--   
--   If the scale has an origin (see <a>scaleSetHasOrigin</a>), there is a
--   subnode with name highlight below the trough node that is used for
--   rendering the highlighted part of the trough.
--   
--   If the scale is showing a fill level (see
--   <a>rangeSetShowFillLevel</a>), there is a subnode with name fill below
--   the trough node that is used for rendering the filled in part of the
--   trough.
--   
--   If marks are present, there is a marks subnode before or after the
--   trough node, below which each mark gets a node with name mark. The
--   marks nodes get either the .top or .bottom style class.
--   
--   The mark node has a subnode named indicator. If the mark has text, it
--   also has a subnode named label. When the mark is either above or left
--   of the scale, the label subnode is the first when present. Otherwise,
--   the indicator subnode is the first.
--   
--   The main CSS node gets the 'marks-before' and/or 'marks-after' style
--   classes added depending on what marks are present.
--   
--   If the scale is displaying the value (see <a>Scale:drawValue</a>),
--   there is subnode with name value. This node will get the .top or
--   .bottom style classes similar to the marks node.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkScale</tt> uses the <a>AccessibleRoleSlider</a> role.
module GI.Gtk.Objects.Scale

-- | Memory-managed wrapper type.
newtype Scale
Scale :: ManagedPtr Scale -> Scale

-- | Type class for types which can be safely cast to <a>Scale</a>, for
--   instance with <a>toScale</a>.
class (GObject o, IsDescendantOf Scale o) => IsScale o

-- | Cast to <a>Scale</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toScale :: (MonadIO m, IsScale o) => o -> m Scale

-- | Adds a mark at <i><tt>value</tt></i>.
--   
--   A mark is indicated visually by drawing a tick mark next to the scale,
--   and GTK makes it easy for the user to position the scale exactly at
--   the marks value.
--   
--   If <i><tt>markup</tt></i> is not <a>Nothing</a>, text is shown next to
--   the tick mark.
--   
--   To remove marks from a scale, use <a>scaleClearMarks</a>.
scaleAddMark :: (HasCallStack, MonadIO m, IsScale a) => a -> Double -> PositionType -> Maybe Text -> m ()

-- | Removes any marks that have been added.
scaleClearMarks :: (HasCallStack, MonadIO m, IsScale a) => a -> m ()

-- | Gets the number of decimal places that are displayed in the value.
scaleGetDigits :: (HasCallStack, MonadIO m, IsScale a) => a -> m Int32

-- | Returns whether the current value is displayed as a string next to the
--   slider.
scaleGetDrawValue :: (HasCallStack, MonadIO m, IsScale a) => a -> m Bool

-- | Returns whether the scale has an origin.
scaleGetHasOrigin :: (HasCallStack, MonadIO m, IsScale a) => a -> m Bool

-- | Gets the <tt>PangoLayout</tt> used to display the scale.
--   
--   The returned object is owned by the scale so does not need to be freed
--   by the caller.
scaleGetLayout :: (HasCallStack, MonadIO m, IsScale a) => a -> m (Maybe Layout)

-- | Obtains the coordinates where the scale will draw the
--   <tt>PangoLayout</tt> representing the text in the scale.
--   
--   Remember when using the <tt>PangoLayout</tt> function you need to
--   convert to and from pixels using <tt>PANGO_PIXELS()</tt> or
--   <tt>PANGO_SCALE</tt>.
--   
--   If the <a>Scale:drawValue</a> property is <a>False</a>, the return
--   values are undefined.
scaleGetLayoutOffsets :: (HasCallStack, MonadIO m, IsScale a) => a -> m (Int32, Int32)

-- | Gets the position in which the current value is displayed.
scaleGetValuePos :: (HasCallStack, MonadIO m, IsScale a) => a -> m PositionType

-- | Creates a new <tt>GtkScale</tt>.
scaleNew :: (HasCallStack, MonadIO m, IsAdjustment a) => Orientation -> Maybe a -> m Scale

-- | Creates a new scale widget with a range from <i><tt>min</tt></i> to
--   <i><tt>max</tt></i>.
--   
--   The returns scale will have the given orientation and will let the
--   user input a number between <i><tt>min</tt></i> and
--   <i><tt>max</tt></i> (including <i><tt>min</tt></i> and
--   <i><tt>max</tt></i>) with the increment <i><tt>step</tt></i>.
--   <i><tt>step</tt></i> must be nonzero; it’s the distance the slider
--   moves when using the arrow keys to adjust the scale value.
--   
--   Note that the way in which the precision is derived works best if
--   <i><tt>step</tt></i> is a power of ten. If the resulting precision is
--   not suitable for your needs, use <a>scaleSetDigits</a> to correct it.
scaleNewWithRange :: (HasCallStack, MonadIO m) => Orientation -> Double -> Double -> Double -> m Scale

-- | Sets the number of decimal places that are displayed in the value.
--   
--   Also causes the value of the adjustment to be rounded to this number
--   of digits, so the retrieved value matches the displayed one, if
--   <a>Scale:drawValue</a> is <a>True</a> when the value changes. If you
--   want to enforce rounding the value when <a>Scale:drawValue</a> is
--   <a>False</a>, you can set <a>Range:roundDigits</a> instead.
--   
--   Note that rounding to a small number of digits can interfere with the
--   smooth autoscrolling that is built into <tt>GtkScale</tt>. As an
--   alternative, you can use <a>scaleSetFormatValueFunc</a> to format the
--   displayed value yourself.
scaleSetDigits :: (HasCallStack, MonadIO m, IsScale a) => a -> Int32 -> m ()

-- | Specifies whether the current value is displayed as a string next to
--   the slider.
scaleSetDrawValue :: (HasCallStack, MonadIO m, IsScale a) => a -> Bool -> m ()

-- | <i><tt>func</tt></i> allows you to change how the scale value is
--   displayed.
--   
--   The given function will return an allocated string representing
--   <i><tt>value</tt></i>. That string will then be used to display the
--   scale's value.
--   
--   If <tt><i>NULL</i></tt> is passed as <i><tt>func</tt></i>, the value
--   will be displayed on its own, rounded according to the value of the
--   <a>Scale:digits</a> property.
scaleSetFormatValueFunc :: (HasCallStack, MonadIO m, IsScale a) => a -> Maybe ScaleFormatValueFunc -> m ()

-- | Sets whether the scale has an origin.
--   
--   If <a>Scale:hasOrigin</a> is set to <a>True</a> (the default), the
--   scale will highlight the part of the trough between the origin (bottom
--   or left side) and the current value.
scaleSetHasOrigin :: (HasCallStack, MonadIO m, IsScale a) => a -> Bool -> m ()

-- | Sets the position in which the current value is displayed.
scaleSetValuePos :: (HasCallStack, MonadIO m, IsScale a) => a -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>digits</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructScaleDigits :: (IsScale o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #digits
--   </pre>
getScaleDigits :: (MonadIO m, IsScale o) => o -> m Int32

-- | Set the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #digits <a>:=</a> value ]
--   </pre>
setScaleDigits :: (MonadIO m, IsScale o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw-value</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleDrawValue :: (IsScale o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>draw-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #drawValue
--   </pre>
getScaleDrawValue :: (MonadIO m, IsScale o) => o -> m Bool

-- | Set the value of the “<tt>draw-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #drawValue <a>:=</a> value ]
--   </pre>
setScaleDrawValue :: (MonadIO m, IsScale o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-origin</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleHasOrigin :: (IsScale o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-origin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #hasOrigin
--   </pre>
getScaleHasOrigin :: (MonadIO m, IsScale o) => o -> m Bool

-- | Set the value of the “<tt>has-origin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #hasOrigin <a>:=</a> value ]
--   </pre>
setScaleHasOrigin :: (MonadIO m, IsScale o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value-pos</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructScaleValuePos :: (IsScale o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>value-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scale #valuePos
--   </pre>
getScaleValuePos :: (MonadIO m, IsScale o) => o -> m PositionType

-- | Set the value of the “<tt>value-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scale [ #valuePos <a>:=</a> value ]
--   </pre>
setScaleValuePos :: (MonadIO m, IsScale o) => o -> PositionType -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Scale.Scale
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Scale.Scale
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Scale.Scale
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Scale.Scale)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Scale.Scale o) => GI.Gtk.Objects.Scale.IsScale o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Scale.Scale
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Scale.Scale


-- | Animates the transition of its child from invisible to visible.
--   
--   The style of transition can be controlled with
--   <a>revealerSetTransitionType</a>.
--   
--   These animations respect the <a>Settings:gtkEnableAnimations</a>
--   setting.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkRevealer</tt> has a single CSS node with name revealer. When
--   styling <tt>GtkRevealer</tt> using CSS, remember that it only hides
--   its contents, not itself. That means applied margin, padding and
--   borders will be visible even when the <a>Revealer:revealChild</a>
--   property is set to <a>False</a>.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkRevealer</tt> uses the <a>AccessibleRoleGroup</a> role.
--   
--   The child of <tt>GtkRevealer</tt>, if set, is always available in the
--   accessibility tree, regardless of the state of the revealer widget.
module GI.Gtk.Objects.Revealer

-- | Memory-managed wrapper type.
newtype Revealer
Revealer :: ManagedPtr Revealer -> Revealer

-- | Type class for types which can be safely cast to <a>Revealer</a>, for
--   instance with <a>toRevealer</a>.
class (GObject o, IsDescendantOf Revealer o) => IsRevealer o

-- | Cast to <a>Revealer</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRevealer :: (MonadIO m, IsRevealer o) => o -> m Revealer

-- | Gets the child widget of <i><tt>revealer</tt></i>.
revealerGetChild :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m (Maybe Widget)

-- | Returns whether the child is fully revealed.
--   
--   In other words, this returns whether the transition to the revealed
--   state is completed.
revealerGetChildRevealed :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Bool

-- | Returns whether the child is currently revealed.
--   
--   This function returns <a>True</a> as soon as the transition is to the
--   revealed state is started. To learn whether the child is fully
--   revealed (ie the transition is completed), use
--   <a>revealerGetChildRevealed</a>.
revealerGetRevealChild :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Bool

-- | Returns the amount of time (in milliseconds) that transitions will
--   take.
revealerGetTransitionDuration :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m Word32

-- | Gets the type of animation that will be used for transitions in
--   <i><tt>revealer</tt></i>.
revealerGetTransitionType :: (HasCallStack, MonadIO m, IsRevealer a) => a -> m RevealerTransitionType

-- | Creates a new <tt>GtkRevealer</tt>.
revealerNew :: (HasCallStack, MonadIO m) => m Revealer

-- | Sets the child widget of <i><tt>revealer</tt></i>.
revealerSetChild :: (HasCallStack, MonadIO m, IsRevealer a, IsWidget b) => a -> Maybe b -> m ()

-- | Tells the <tt>GtkRevealer</tt> to reveal or conceal its child.
--   
--   The transition will be animated with the current transition type of
--   <i><tt>revealer</tt></i>.
revealerSetRevealChild :: (HasCallStack, MonadIO m, IsRevealer a) => a -> Bool -> m ()

-- | Sets the duration that transitions will take.
revealerSetTransitionDuration :: (HasCallStack, MonadIO m, IsRevealer a) => a -> Word32 -> m ()

-- | Sets the type of animation that will be used for transitions in
--   <i><tt>revealer</tt></i>.
--   
--   Available types include various kinds of fades and slides.
revealerSetTransitionType :: (HasCallStack, MonadIO m, IsRevealer a) => a -> RevealerTransitionType -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearRevealerChild :: (MonadIO m, IsRevealer o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRevealerChild :: (IsRevealer o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #child
--   </pre>
getRevealerChild :: (MonadIO m, IsRevealer o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revealer [ #child <a>:=</a> value ]
--   </pre>
setRevealerChild :: (MonadIO m, IsRevealer o, IsWidget a) => o -> a -> m ()

-- | Get the value of the “<tt>child-revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #childRevealed
--   </pre>
getRevealerChildRevealed :: (MonadIO m, IsRevealer o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reveal-child</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRevealerRevealChild :: (IsRevealer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>reveal-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #revealChild
--   </pre>
getRevealerRevealChild :: (MonadIO m, IsRevealer o) => o -> m Bool

-- | Set the value of the “<tt>reveal-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revealer [ #revealChild <a>:=</a> value ]
--   </pre>
setRevealerRevealChild :: (MonadIO m, IsRevealer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-duration</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructRevealerTransitionDuration :: (IsRevealer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #transitionDuration
--   </pre>
getRevealerTransitionDuration :: (MonadIO m, IsRevealer o) => o -> m Word32

-- | Set the value of the “<tt>transition-duration</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revealer [ #transitionDuration <a>:=</a> value ]
--   </pre>
setRevealerTransitionDuration :: (MonadIO m, IsRevealer o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transition-type</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructRevealerTransitionType :: (IsRevealer o, MonadIO m) => RevealerTransitionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revealer #transitionType
--   </pre>
getRevealerTransitionType :: (MonadIO m, IsRevealer o) => o -> m RevealerTransitionType

-- | Set the value of the “<tt>transition-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revealer [ #transitionType <a>:=</a> value ]
--   </pre>
setRevealerTransitionType :: (MonadIO m, IsRevealer o) => o -> RevealerTransitionType -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Revealer.Revealer
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Revealer.Revealer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Revealer.Revealer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Revealer.Revealer)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Revealer.Revealer o) => GI.Gtk.Objects.Revealer.IsRevealer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Revealer.Revealer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Revealer.Revealer


-- | Base class for widgets which visualize an adjustment.
--   
--   Widgets that are derived from <tt>GtkRange</tt> include <a>Scale</a>
--   and <a>Scrollbar</a>.
--   
--   Apart from signals for monitoring the parameters of the adjustment,
--   <tt>GtkRange</tt> provides properties and methods for setting a “fill
--   level” on range widgets. See <a>rangeSetFillLevel</a>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The <tt>GtkRange</tt> slider is draggable. Holding the
--   &lt;kbd&gt;Shift&lt;/kbd&gt; key while dragging, or initiating the
--   drag with a long-press will enable the fine-tuning mode.
module GI.Gtk.Objects.Range

-- | Memory-managed wrapper type.
newtype Range
Range :: ManagedPtr Range -> Range

-- | Type class for types which can be safely cast to <a>Range</a>, for
--   instance with <a>toRange</a>.
class (GObject o, IsDescendantOf Range o) => IsRange o

-- | Cast to <a>Range</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRange :: (MonadIO m, IsRange o) => o -> m Range

-- | Get the adjustment which is the “model” object for <tt>GtkRange</tt>.
rangeGetAdjustment :: (HasCallStack, MonadIO m, IsRange a) => a -> m Adjustment

-- | Gets the current position of the fill level indicator.
rangeGetFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Double

-- | Gets whether the <tt>GtkRange</tt> respects text direction.
--   
--   See <a>rangeSetFlippable</a>.
rangeGetFlippable :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets whether the range is inverted.
--   
--   See <a>rangeSetInverted</a>.
rangeGetInverted :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | This function returns the area that contains the range’s trough, in
--   coordinates relative to <i><tt>range</tt></i>'s origin.
--   
--   This function is useful mainly for <tt>GtkRange</tt> subclasses.
rangeGetRangeRect :: (HasCallStack, MonadIO m, IsRange a) => a -> m Rectangle

-- | Gets whether the range is restricted to the fill level.
rangeGetRestrictToFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the number of digits to round the value to when it changes.
--   
--   See <a>Range::changeValue</a>.
rangeGetRoundDigits :: (HasCallStack, MonadIO m, IsRange a) => a -> m Int32

-- | Gets whether the range displays the fill level graphically.
rangeGetShowFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | This function returns sliders range along the long dimension, in
--   widget-&gt;window coordinates.
--   
--   This function is useful mainly for <tt>GtkRange</tt> subclasses.
rangeGetSliderRange :: (HasCallStack, MonadIO m, IsRange a) => a -> m (Int32, Int32)

-- | This function is useful mainly for <tt>GtkRange</tt> subclasses.
--   
--   See <a>rangeSetSliderSizeFixed</a>.
rangeGetSliderSizeFixed :: (HasCallStack, MonadIO m, IsRange a) => a -> m Bool

-- | Gets the current value of the range.
rangeGetValue :: (HasCallStack, MonadIO m, IsRange a) => a -> m Double

-- | Sets the adjustment to be used as the “model” object for the
--   <tt>GtkRange</tt>
--   
--   The adjustment indicates the current range value, the minimum and
--   maximum range values, the step/page increments used for keybindings
--   and scrolling, and the page size.
--   
--   The page size is normally 0 for <tt>GtkScale</tt> and nonzero for
--   <tt>GtkScrollbar</tt>, and indicates the size of the visible area of
--   the widget being scrolled. The page size affects the size of the
--   scrollbar slider.
rangeSetAdjustment :: (HasCallStack, MonadIO m, IsRange a, IsAdjustment b) => a -> b -> m ()

-- | Set the new position of the fill level indicator.
--   
--   The “fill level” is probably best described by its most prominent use
--   case, which is an indicator for the amount of pre-buffering in a
--   streaming media player. In that use case, the value of the range would
--   indicate the current play position, and the fill level would be the
--   position up to which the file/stream has been downloaded.
--   
--   This amount of prebuffering can be displayed on the range’s trough and
--   is themeable separately from the trough. To enable fill level display,
--   use <a>rangeSetShowFillLevel</a>. The range defaults to not showing
--   the fill level.
--   
--   Additionally, it’s possible to restrict the range’s slider position to
--   values which are smaller than the fill level. This is controlled by
--   <a>rangeSetRestrictToFillLevel</a> and is by default enabled.
rangeSetFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> m ()

-- | Sets whether the <tt>GtkRange</tt> respects text direction.
--   
--   If a range is flippable, it will switch its direction if it is
--   horizontal and its direction is <a>TextDirectionRtl</a>.
--   
--   See <a>widgetGetDirection</a>.
rangeSetFlippable :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the step and page sizes for the range.
--   
--   The step size is used when the user clicks the <tt>GtkScrollbar</tt>
--   arrows or moves a <tt>GtkScale</tt> via arrow keys. The page size is
--   used for example when moving via Page Up or Page Down keys.
rangeSetIncrements :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> Double -> m ()

-- | Sets whether to invert the range.
--   
--   Ranges normally move from lower to higher values as the slider moves
--   from top to bottom or left to right. Inverted ranges have higher
--   values at the top or on the right rather than on the bottom or left.
rangeSetInverted :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the allowable values in the <tt>GtkRange</tt>.
--   
--   The range value is clamped to be between <i><tt>min</tt></i> and
--   <i><tt>max</tt></i>. (If the range has a non-zero page size, it is
--   clamped between <i><tt>min</tt></i> and <i><tt>max</tt></i> -
--   page-size.)
rangeSetRange :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> Double -> m ()

-- | Sets whether the slider is restricted to the fill level.
--   
--   See <a>rangeSetFillLevel</a> for a general description of the fill
--   level concept.
rangeSetRestrictToFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the number of digits to round the value to when it changes.
--   
--   See <a>Range::changeValue</a>.
rangeSetRoundDigits :: (HasCallStack, MonadIO m, IsRange a) => a -> Int32 -> m ()

-- | Sets whether a graphical fill level is show on the trough.
--   
--   See <a>rangeSetFillLevel</a> for a general description of the fill
--   level concept.
rangeSetShowFillLevel :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets whether the range’s slider has a fixed size, or a size that
--   depends on its adjustment’s page size.
--   
--   This function is useful mainly for <tt>GtkRange</tt> subclasses.
rangeSetSliderSizeFixed :: (HasCallStack, MonadIO m, IsRange a) => a -> Bool -> m ()

-- | Sets the current value of the range.
--   
--   If the value is outside the minimum or maximum range values, it will
--   be clamped to fit inside them. The range emits the
--   <a>Range::valueChanged</a> signal if the value changes.
rangeSetValue :: (HasCallStack, MonadIO m, IsRange a) => a -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRangeAdjustment :: (IsRange o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #adjustment
--   </pre>
getRangeAdjustment :: (MonadIO m, IsRange o) => o -> m Adjustment

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #adjustment <a>:=</a> value ]
--   </pre>
setRangeAdjustment :: (MonadIO m, IsRange o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fill-level</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRangeFillLevel :: (IsRange o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #fillLevel
--   </pre>
getRangeFillLevel :: (MonadIO m, IsRange o) => o -> m Double

-- | Set the value of the “<tt>fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #fillLevel <a>:=</a> value ]
--   </pre>
setRangeFillLevel :: (MonadIO m, IsRange o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRangeInverted :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #inverted
--   </pre>
getRangeInverted :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #inverted <a>:=</a> value ]
--   </pre>
setRangeInverted :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>restrict-to-fill-level</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructRangeRestrictToFillLevel :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>restrict-to-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #restrictToFillLevel
--   </pre>
getRangeRestrictToFillLevel :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “<tt>restrict-to-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #restrictToFillLevel <a>:=</a> value ]
--   </pre>
setRangeRestrictToFillLevel :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>round-digits</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRangeRoundDigits :: (IsRange o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>round-digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #roundDigits
--   </pre>
getRangeRoundDigits :: (MonadIO m, IsRange o) => o -> m Int32

-- | Set the value of the “<tt>round-digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #roundDigits <a>:=</a> value ]
--   </pre>
setRangeRoundDigits :: (MonadIO m, IsRange o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-fill-level</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructRangeShowFillLevel :: (IsRange o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> range #showFillLevel
--   </pre>
getRangeShowFillLevel :: (MonadIO m, IsRange o) => o -> m Bool

-- | Set the value of the “<tt>show-fill-level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> range [ #showFillLevel <a>:=</a> value ]
--   </pre>
setRangeShowFillLevel :: (MonadIO m, IsRange o) => o -> Bool -> m ()

-- | Emitted before clamping a value, to give the application a chance to
--   adjust the bounds.
type RangeAdjustBoundsCallback = Double -> IO ()

-- | Connect a signal handler for the <a>adjustBounds</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #adjustBounds callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeAdjustBounds :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeAdjustBoundsCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>adjustBounds</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #adjustBounds callback
--   </pre>
onRangeAdjustBounds :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeAdjustBoundsCallback) -> m SignalHandlerId

-- | Emitted when a scroll action is performed on a range.
--   
--   It allows an application to determine the type of scroll event that
--   occurred and the resultant new value. The application can handle the
--   event itself and return <a>True</a> to prevent further processing. Or,
--   by returning <a>False</a>, it can pass the event to other handlers
--   until the default GTK handler is reached.
--   
--   The value parameter is unrounded. An application that overrides the
--   <a>changeValue</a> signal is responsible for clamping the value to the
--   desired number of decimal digits; the default GTK handler clamps the
--   value based on <a>Range:roundDigits</a>.
type RangeChangeValueCallback = ScrollType -> Double -> IO Bool

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #changeValue callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeChangeValue :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeChangeValueCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeValue</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #changeValue callback
--   </pre>
onRangeChangeValue :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeChangeValueCallback) -> m SignalHandlerId

-- | Virtual function that moves the slider.
--   
--   Used for keybindings.
type RangeMoveSliderCallback = ScrollType -> IO ()

-- | Connect a signal handler for the <a>moveSlider</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #moveSlider callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeMoveSlider :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeMoveSliderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveSlider</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #moveSlider callback
--   </pre>
onRangeMoveSlider :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeMoveSliderCallback) -> m SignalHandlerId

-- | Emitted when the range value changes.
type RangeValueChangedCallback = IO ()

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> range #valueChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRangeValueChanged :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeValueChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>valueChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> range #valueChanged callback
--   </pre>
onRangeValueChanged :: (IsRange a, MonadIO m) => a -> ((?self :: a) => RangeValueChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Range.Range
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Range.Range
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Range.Range
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Range.Range)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Range.Range o) => GI.Gtk.Objects.Range.IsRange o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Range.Range
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Range.Range


-- | A <tt>GObject</tt> property value in a <tt>GtkExpression</tt>.
module GI.Gtk.Objects.PropertyExpression

-- | Memory-managed wrapper type.
newtype PropertyExpression
PropertyExpression :: ManagedPtr PropertyExpression -> PropertyExpression

-- | Type class for types which can be safely cast to
--   <a>PropertyExpression</a>, for instance with
--   <a>toPropertyExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf PropertyExpression o) => IsPropertyExpression o

-- | Cast to <a>PropertyExpression</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toPropertyExpression :: (MonadIO m, IsPropertyExpression o) => o -> m PropertyExpression

-- | Gets the expression specifying the object of a property expression.
propertyExpressionGetExpression :: (HasCallStack, MonadIO m, IsPropertyExpression a) => a -> m (Maybe Expression)

-- | Gets the <tt>GParamSpec</tt> specifying the property of a property
--   expression.
propertyExpressionGetPspec :: (HasCallStack, MonadIO m, IsPropertyExpression a) => a -> m GParamSpec

-- | Creates an expression that looks up a property.
--   
--   The object to use is found by evaluating the <tt>expression</tt>, or
--   using the <tt>this</tt> argument when <tt>expression</tt> is
--   <tt>NULL</tt>.
--   
--   If the resulting object conforms to <tt>this_type</tt>, its property
--   named <tt>property_name</tt> will be queried. Otherwise, this
--   expression's evaluation will fail.
--   
--   The given <tt>this_type</tt> must have a property with
--   <tt>property_name</tt>.
propertyExpressionNew :: (HasCallStack, MonadIO m, IsExpression a) => GType -> Maybe a -> Text -> m PropertyExpression

-- | Creates an expression that looks up a property.
--   
--   The object to use is found by evaluating the <tt>expression</tt>, or
--   using the <tt>this</tt> argument when <tt>expression</tt> is
--   <tt>NULL</tt>.
--   
--   If the resulting object conforms to <tt>this_type</tt>, its property
--   specified by <tt>pspec</tt> will be queried. Otherwise, this
--   expression's evaluation will fail.
propertyExpressionNewForPspec :: (HasCallStack, MonadIO m, IsExpression a) => Maybe a -> GParamSpec -> m PropertyExpression
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.PropertyExpression.PropertyExpression
instance GHC.Classes.Eq GI.Gtk.Objects.PropertyExpression.PropertyExpression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PropertyExpression.PropertyExpression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PropertyExpression.PropertyExpression o) => GI.Gtk.Objects.PropertyExpression.IsPropertyExpression o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PropertyExpression.PropertyExpression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PropertyExpression.PropertyExpression


-- | Displays the progress of a long-running operation.
--   
--   <tt>GtkProgressBar</tt> provides a visual clue that processing is
--   underway. It can be used in two different modes: percentage mode and
--   activity mode.
--   
--   &lt;picture&gt; &lt;source srcset="progressbar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkProgressBar" src="progressbar.png"&gt; &lt;/picture&gt;
--   
--   When an application can determine how much work needs to take place
--   (e.g. read a fixed number of bytes from a file) and can monitor its
--   progress, it can use the <tt>GtkProgressBar</tt> in percentage mode
--   and the user sees a growing bar indicating the percentage of the work
--   that has been completed. In this mode, the application is required to
--   call <a>progressBarSetFraction</a> periodically to update the progress
--   bar.
--   
--   When an application has no accurate way of knowing the amount of work
--   to do, it can use the <tt>GtkProgressBar</tt> in activity mode, which
--   shows activity by a block moving back and forth within the progress
--   area. In this mode, the application is required to call
--   <a>progressBarPulse</a> periodically to update the progress bar.
--   
--   There is quite a bit of flexibility provided to control the appearance
--   of the <tt>GtkProgressBar</tt>. Functions are provided to control the
--   orientation of the bar, optional text can be displayed along with the
--   bar, and the step size used in activity mode can be set.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   progressbar[.osd]
--   ├── [text]
--   ╰── trough[.empty][.full]
--       ╰── progress[.pulse]
--   </pre>
--   
--   <tt>GtkProgressBar</tt> has a main CSS node with name progressbar and
--   subnodes with names text and trough, of which the latter has a subnode
--   named progress. The text subnode is only present if text is shown. The
--   progress subnode has the style class .pulse when in activity mode. It
--   gets the style classes .left, .right, .top or .bottom added when the
--   progress 'touches' the corresponding end of the GtkProgressBar. The
--   .osd class on the progressbar node is for use in overlays like the one
--   Epiphany has for page loading progress.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkProgressBar</tt> uses the <a>AccessibleRoleProgressBar</a> role
--   and sets the <a>AccessiblePropertyValueMin</a>,
--   <a>AccessiblePropertyValueMax</a> and
--   <a>AccessiblePropertyValueNow</a> properties to reflect the progress.
module GI.Gtk.Objects.ProgressBar

-- | Memory-managed wrapper type.
newtype ProgressBar
ProgressBar :: ManagedPtr ProgressBar -> ProgressBar

-- | Type class for types which can be safely cast to <a>ProgressBar</a>,
--   for instance with <a>toProgressBar</a>.
class (GObject o, IsDescendantOf ProgressBar o) => IsProgressBar o

-- | Cast to <a>ProgressBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toProgressBar :: (MonadIO m, IsProgressBar o) => o -> m ProgressBar

-- | Returns the ellipsizing position of the progress bar.
--   
--   See <a>progressBarSetEllipsize</a>.
progressBarGetEllipsize :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m EllipsizeMode

-- | Returns the current fraction of the task that’s been completed.
progressBarGetFraction :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Double

-- | Returns whether the progress bar is inverted.
progressBarGetInverted :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Bool

-- | Retrieves the pulse step.
--   
--   See <a>progressBarSetPulseStep</a>.
progressBarGetPulseStep :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Double

-- | Returns whether the <tt>GtkProgressBar</tt> shows text.
--   
--   See <a>progressBarSetShowText</a>.
progressBarGetShowText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m Bool

-- | Retrieves the text that is displayed with the progress bar.
--   
--   The return value is a reference to the text, not a copy of it, so will
--   become invalid if you change the text in the progress bar.
progressBarGetText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m (Maybe Text)

-- | Creates a new <tt>GtkProgressBar</tt>.
progressBarNew :: (HasCallStack, MonadIO m) => m ProgressBar

-- | Indicates that some progress has been made, but you don’t know how
--   much.
--   
--   Causes the progress bar to enter “activity mode,” where a block
--   bounces back and forth. Each call to <a>progressBarPulse</a> causes
--   the block to move by a little bit (the amount of movement per pulse is
--   determined by <a>progressBarSetPulseStep</a>).
progressBarPulse :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> m ()

-- | Sets the mode used to ellipsize the text.
--   
--   The text is ellipsized if there is not enough space to render the
--   entire string.
progressBarSetEllipsize :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> EllipsizeMode -> m ()

-- | Causes the progress bar to “fill in” the given fraction of the bar.
--   
--   The fraction should be between 0.0 and 1.0, inclusive.
progressBarSetFraction :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Double -> m ()

-- | Sets whether the progress bar is inverted.
--   
--   Progress bars normally grow from top to bottom or left to right.
--   Inverted progress bars grow in the opposite direction.
progressBarSetInverted :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Bool -> m ()

-- | Sets the fraction of total progress bar length to move the bouncing
--   block.
--   
--   The bouncing block is moved when <a>progressBarPulse</a> is called.
progressBarSetPulseStep :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Double -> m ()

-- | Sets whether the progress bar will show text next to the bar.
--   
--   The shown text is either the value of the <a>ProgressBar:text</a>
--   property or, if that is <a>Nothing</a>, the
--   <a>ProgressBar:fraction</a> value, as a percentage.
--   
--   To make a progress bar that is styled and sized suitably for
--   containing text (even if the actual text is blank), set
--   <a>ProgressBar:showText</a> to <a>True</a> and <a>ProgressBar:text</a>
--   to the empty string (not <a>Nothing</a>).
progressBarSetShowText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Bool -> m ()

-- | Causes the given <i><tt>text</tt></i> to appear next to the progress
--   bar.
--   
--   If <i><tt>text</tt></i> is <a>Nothing</a> and
--   <a>ProgressBar:showText</a> is <a>True</a>, the current value of
--   <a>ProgressBar:fraction</a> will be displayed as a percentage.
--   
--   If <i><tt>text</tt></i> is non-<a>Nothing</a> and
--   <a>ProgressBar:showText</a> is <a>True</a>, the text will be
--   displayed. In this case, it will not display the progress percentage.
--   If <i><tt>text</tt></i> is the empty string, the progress bar will
--   still be styled and sized suitably for containing text, as long as
--   <a>ProgressBar:showText</a> is <a>True</a>.
progressBarSetText :: (HasCallStack, MonadIO m, IsProgressBar a) => a -> Maybe Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarEllipsize :: (IsProgressBar o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #ellipsize
--   </pre>
getProgressBarEllipsize :: (MonadIO m, IsProgressBar o) => o -> m EllipsizeMode

-- | Set the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #ellipsize <a>:=</a> value ]
--   </pre>
setProgressBarEllipsize :: (MonadIO m, IsProgressBar o) => o -> EllipsizeMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fraction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarFraction :: (IsProgressBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #fraction
--   </pre>
getProgressBarFraction :: (MonadIO m, IsProgressBar o) => o -> m Double

-- | Set the value of the “<tt>fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #fraction <a>:=</a> value ]
--   </pre>
setProgressBarFraction :: (MonadIO m, IsProgressBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarInverted :: (IsProgressBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #inverted
--   </pre>
getProgressBarInverted :: (MonadIO m, IsProgressBar o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #inverted <a>:=</a> value ]
--   </pre>
setProgressBarInverted :: (MonadIO m, IsProgressBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pulse-step</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarPulseStep :: (IsProgressBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #pulseStep
--   </pre>
getProgressBarPulseStep :: (MonadIO m, IsProgressBar o) => o -> m Double

-- | Set the value of the “<tt>pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #pulseStep <a>:=</a> value ]
--   </pre>
setProgressBarPulseStep :: (MonadIO m, IsProgressBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-text</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructProgressBarShowText :: (IsProgressBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #showText
--   </pre>
getProgressBarShowText :: (MonadIO m, IsProgressBar o) => o -> m Bool

-- | Set the value of the “<tt>show-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #showText <a>:=</a> value ]
--   </pre>
setProgressBarShowText :: (MonadIO m, IsProgressBar o) => o -> Bool -> m ()

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearProgressBarText :: (MonadIO m, IsProgressBar o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructProgressBarText :: (IsProgressBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> progressBar #text
--   </pre>
getProgressBarText :: (MonadIO m, IsProgressBar o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> progressBar [ #text <a>:=</a> value ]
--   </pre>
setProgressBarText :: (MonadIO m, IsProgressBar o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ProgressBar.ProgressBar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ProgressBar.ProgressBar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ProgressBar.ProgressBar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ProgressBar.ProgressBar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ProgressBar.ProgressBar o) => GI.Gtk.Objects.ProgressBar.IsProgressBar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ProgressBar.ProgressBar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ProgressBar.ProgressBar


-- | A print dialog for platforms which don’t provide a native print
--   dialog, like Unix.
--   
--   &lt;picture&gt; &lt;source srcset="printdialog-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPrintUnixDialog" src="printdialog.png"&gt; &lt;/picture&gt;
--   
--   It can be used very much like any other GTK dialog, at the cost of the
--   portability offered by the high-level printing API with
--   <a>PrintOperation</a>.
--   
--   In order to print something with <tt>GtkPrintUnixDialog</tt>, you need
--   to use <a>printUnixDialogGetSelectedPrinter</a> to obtain a
--   <a>Printer</a> object and use it to construct a <a>PrintJob</a> using
--   <a>printJobNew</a>.
--   
--   <tt>GtkPrintUnixDialog</tt> uses the following response values:
--   
--   <ul>
--   <li><a>ResponseTypeOk</a>: for the “Print” button</li>
--   <li><a>ResponseTypeApply</a>: for the “Preview” button</li>
--   <li><a>ResponseTypeCancel</a>: for the “Cancel” button</li>
--   </ul>
--   
--   <h1>GtkPrintUnixDialog as GtkBuildable</h1>
--   
--   The <tt>GtkPrintUnixDialog</tt> implementation of the
--   <tt>GtkBuildable</tt> interface exposes its <i><tt>notebook</tt></i>
--   internal children with the name “notebook”.
--   
--   An example of a <tt>GtkPrintUnixDialog</tt> UI definition fragment:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkPrintUnixDialog" id="dialog1"&gt;
--     &lt;child internal-child="notebook"&gt;
--       &lt;object class="GtkNotebook" id="notebook"&gt;
--         &lt;child&gt;
--           &lt;object type="GtkNotebookPage"&gt;
--             &lt;property name="tab_expand"&gt;False&lt;/property&gt;
--             &lt;property name="tab_fill"&gt;False&lt;/property&gt;
--             &lt;property name="tab"&gt;
--               &lt;object class="GtkLabel" id="tablabel"&gt;
--                 &lt;property name="label"&gt;Tab label&lt;/property&gt;
--               &lt;/object&gt;
--             &lt;/property&gt;
--             &lt;property name="child"&gt;
--               &lt;object class="GtkLabel" id="tabcontent"&gt;
--                 &lt;property name="label"&gt;Content on notebook tab&lt;/property&gt;
--               &lt;/object&gt;
--             &lt;/property&gt;
--           &lt;/object&gt;
--         &lt;/child&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkPrintUnixDialog</tt> has a single CSS node with name window.
--   The style classes dialog and print are added.
module GI.Gtk.Objects.PrintUnixDialog

-- | Memory-managed wrapper type.
newtype PrintUnixDialog
PrintUnixDialog :: ManagedPtr PrintUnixDialog -> PrintUnixDialog

-- | Type class for types which can be safely cast to
--   <a>PrintUnixDialog</a>, for instance with <a>toPrintUnixDialog</a>.
class (GObject o, IsDescendantOf PrintUnixDialog o) => IsPrintUnixDialog o

-- | Cast to <a>PrintUnixDialog</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toPrintUnixDialog :: (MonadIO m, IsPrintUnixDialog o) => o -> m PrintUnixDialog

-- | Adds a custom tab to the print dialog.
printUnixDialogAddCustomTab :: (HasCallStack, MonadIO m, IsPrintUnixDialog a, IsWidget b, IsWidget c) => a -> b -> c -> m ()

-- | Gets the current page of the <tt>GtkPrintUnixDialog</tt>.
printUnixDialogGetCurrentPage :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m Int32

-- | Gets whether to embed the page setup.
printUnixDialogGetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m Bool

-- | Gets whether there is a selection.
printUnixDialogGetHasSelection :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m Bool

-- | Gets the capabilities that have been set on this
--   <tt>GtkPrintUnixDialog</tt>.
printUnixDialogGetManualCapabilities :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m [PrintCapabilities]

-- | Gets the page setup that is used by the <tt>GtkPrintUnixDialog</tt>.
printUnixDialogGetPageSetup :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m PageSetup

-- | Gets whether a page setup was set by the user.
printUnixDialogGetPageSetupSet :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m Bool

-- | Gets the currently selected printer.
printUnixDialogGetSelectedPrinter :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m (Maybe Printer)

-- | Gets a new <tt>GtkPrintSettings</tt> object that represents the
--   current values in the print dialog.
--   
--   Note that this creates a new object, and you need to unref it if don’t
--   want to keep it.
printUnixDialogGetSettings :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m PrintSettings

-- | Gets whether the print dialog allows user to print a selection.
printUnixDialogGetSupportSelection :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> m Bool

-- | Creates a new <tt>GtkPrintUnixDialog</tt>.
printUnixDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m PrintUnixDialog

-- | Sets the current page number.
--   
--   If <i><tt>currentPage</tt></i> is not -1, this enables the current
--   page choice for the range of pages to print.
printUnixDialogSetCurrentPage :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> Int32 -> m ()

-- | Embed page size combo box and orientation combo box into page setup
--   page.
printUnixDialogSetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> Bool -> m ()

-- | Sets whether a selection exists.
printUnixDialogSetHasSelection :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> Bool -> m ()

-- | This lets you specify the printing capabilities your application
--   supports.
--   
--   For instance, if you can handle scaling the output then you pass
--   <a>PrintCapabilitiesScale</a>. If you don’t pass that, then the dialog
--   will only let you select the scale if the printing system
--   automatically handles scaling.
printUnixDialogSetManualCapabilities :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> [PrintCapabilities] -> m ()

-- | Sets the page setup of the <tt>GtkPrintUnixDialog</tt>.
printUnixDialogSetPageSetup :: (HasCallStack, MonadIO m, IsPrintUnixDialog a, IsPageSetup b) => a -> b -> m ()

-- | Sets the <tt>GtkPrintSettings</tt> for the
--   <tt>GtkPrintUnixDialog</tt>.
--   
--   Typically, this is used to restore saved print settings from a
--   previous print operation before the print dialog is shown.
printUnixDialogSetSettings :: (HasCallStack, MonadIO m, IsPrintUnixDialog a, IsPrintSettings b) => a -> Maybe b -> m ()

-- | Sets whether the print dialog allows user to print a selection.
printUnixDialogSetSupportSelection :: (HasCallStack, MonadIO m, IsPrintUnixDialog a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-page</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintUnixDialogCurrentPage :: (IsPrintUnixDialog o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>current-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #currentPage
--   </pre>
getPrintUnixDialogCurrentPage :: (MonadIO m, IsPrintUnixDialog o) => o -> m Int32

-- | Set the value of the “<tt>current-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printUnixDialog [ #currentPage <a>:=</a> value ]
--   </pre>
setPrintUnixDialogCurrentPage :: (MonadIO m, IsPrintUnixDialog o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>embed-page-setup</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintUnixDialogEmbedPageSetup :: (IsPrintUnixDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>embed-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #embedPageSetup
--   </pre>
getPrintUnixDialogEmbedPageSetup :: (MonadIO m, IsPrintUnixDialog o) => o -> m Bool

-- | Set the value of the “<tt>embed-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printUnixDialog [ #embedPageSetup <a>:=</a> value ]
--   </pre>
setPrintUnixDialogEmbedPageSetup :: (MonadIO m, IsPrintUnixDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-selection</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintUnixDialogHasSelection :: (IsPrintUnixDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #hasSelection
--   </pre>
getPrintUnixDialogHasSelection :: (MonadIO m, IsPrintUnixDialog o) => o -> m Bool

-- | Set the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printUnixDialog [ #hasSelection <a>:=</a> value ]
--   </pre>
setPrintUnixDialogHasSelection :: (MonadIO m, IsPrintUnixDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>manual-capabilities</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPrintUnixDialogManualCapabilities :: (IsPrintUnixDialog o, MonadIO m) => [PrintCapabilities] -> m (GValueConstruct o)

-- | Get the value of the “<tt>manual-capabilities</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #manualCapabilities
--   </pre>
getPrintUnixDialogManualCapabilities :: (MonadIO m, IsPrintUnixDialog o) => o -> m [PrintCapabilities]

-- | Set the value of the “<tt>manual-capabilities</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printUnixDialog [ #manualCapabilities <a>:=</a> value ]
--   </pre>
setPrintUnixDialogManualCapabilities :: (MonadIO m, IsPrintUnixDialog o) => o -> [PrintCapabilities] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-setup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrintUnixDialogPageSetup :: (IsPrintUnixDialog o, MonadIO m, IsPageSetup a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #pageSetup
--   </pre>
getPrintUnixDialogPageSetup :: (MonadIO m, IsPrintUnixDialog o) => o -> m PageSetup

-- | Set the value of the “<tt>page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printUnixDialog [ #pageSetup <a>:=</a> value ]
--   </pre>
setPrintUnixDialogPageSetup :: (MonadIO m, IsPrintUnixDialog o, IsPageSetup a) => o -> a -> m ()

-- | Set the value of the “<tt>print-settings</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #printSettings
--   </pre>
clearPrintUnixDialogPrintSettings :: (MonadIO m, IsPrintUnixDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>print-settings</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintUnixDialogPrintSettings :: (IsPrintUnixDialog o, MonadIO m, IsPrintSettings a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #printSettings
--   </pre>
getPrintUnixDialogPrintSettings :: (MonadIO m, IsPrintUnixDialog o) => o -> m (Maybe PrintSettings)

-- | Set the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printUnixDialog [ #printSettings <a>:=</a> value ]
--   </pre>
setPrintUnixDialogPrintSettings :: (MonadIO m, IsPrintUnixDialog o, IsPrintSettings a) => o -> a -> m ()

-- | Get the value of the “<tt>selected-printer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #selectedPrinter
--   </pre>
getPrintUnixDialogSelectedPrinter :: (MonadIO m, IsPrintUnixDialog o) => o -> m (Maybe Printer)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>support-selection</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintUnixDialogSupportSelection :: (IsPrintUnixDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>support-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printUnixDialog #supportSelection
--   </pre>
getPrintUnixDialogSupportSelection :: (MonadIO m, IsPrintUnixDialog o) => o -> m Bool

-- | Set the value of the “<tt>support-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printUnixDialog [ #supportSelection <a>:=</a> value ]
--   </pre>
setPrintUnixDialogSupportSelection :: (MonadIO m, IsPrintUnixDialog o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PrintUnixDialog.PrintUnixDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PrintUnixDialog.PrintUnixDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PrintUnixDialog.PrintUnixDialog
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PrintUnixDialog.PrintUnixDialog)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PrintUnixDialog.PrintUnixDialog o) => GI.Gtk.Objects.PrintUnixDialog.IsPrintUnixDialog o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PrintUnixDialog.PrintUnixDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PrintUnixDialog.PrintUnixDialog


-- | Collects the settings of a print dialog in a system-independent way.
--   
--   The main use for this object is that once you’ve printed you can get a
--   settings object that represents the settings the user chose, and the
--   next time you print you can pass that object in so that the user
--   doesn’t have to re-set all his settings.
--   
--   Its also possible to enumerate the settings so that you can easily
--   save the settings for the next time your app runs, or even store them
--   in a document. The predefined keys try to use shared values as much as
--   possible so that moving such a document between systems still works.
module GI.Gtk.Objects.PrintSettings

-- | Memory-managed wrapper type.
newtype PrintSettings
PrintSettings :: ManagedPtr PrintSettings -> PrintSettings

-- | Type class for types which can be safely cast to <a>PrintSettings</a>,
--   for instance with <a>toPrintSettings</a>.
class (GObject o, IsDescendantOf PrintSettings o) => IsPrintSettings o

-- | Cast to <a>PrintSettings</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPrintSettings :: (MonadIO m, IsPrintSettings o) => o -> m PrintSettings

-- | Copies a <tt>GtkPrintSettings</tt> object.
printSettingsCopy :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintSettings

-- | Calls <i><tt>func</tt></i> for each key-value pair of
--   <i><tt>settings</tt></i>.
printSettingsForeach :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintSettingsFunc -> m ()

-- | Looks up the string value associated with <i><tt>key</tt></i>.
printSettingsGet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m (Maybe Text)

-- | Returns the boolean represented by the value that is associated with
--   <i><tt>key</tt></i>.
--   
--   The string “true” represents <a>True</a>, any other string
--   <a>False</a>.
printSettingsGetBool :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Bool

-- | Gets the value of <a>PRINT_SETTINGS_COLLATE</a>.
printSettingsGetCollate :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Gets the value of <a>PRINT_SETTINGS_DEFAULT_SOURCE</a>.
printSettingsGetDefaultSource :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m (Maybe Text)

-- | Gets the value of <a>PRINT_SETTINGS_DITHER</a>.
printSettingsGetDither :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m (Maybe Text)

-- | Returns the double value associated with <i><tt>key</tt></i>, or 0.
printSettingsGetDouble :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Double

-- | Returns the floating point number represented by the value that is
--   associated with <i><tt>key</tt></i>, or <i><tt>defaultVal</tt></i> if
--   the value does not represent a floating point number.
--   
--   Floating point numbers are parsed with <a>asciiStrtod</a>.
printSettingsGetDoubleWithDefault :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_DUPLEX</a>.
printSettingsGetDuplex :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintDuplex

-- | Gets the value of <a>PRINT_SETTINGS_FINISHINGS</a>.
printSettingsGetFinishings :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m (Maybe Text)

-- | Returns the integer value of <i><tt>key</tt></i>, or 0.
printSettingsGetInt :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Int32

-- | Returns the value of <i><tt>key</tt></i>, interpreted as an integer,
--   or the default value.
printSettingsGetIntWithDefault :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Int32 -> m Int32

-- | Returns the value associated with <i><tt>key</tt></i>, interpreted as
--   a length.
--   
--   The returned value is converted to <i><tt>units</tt></i>.
printSettingsGetLength :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Unit -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_MEDIA_TYPE</a>.
--   
--   The set of media types is defined in PWG 5101.1-2002 PWG.
printSettingsGetMediaType :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m (Maybe Text)

-- | Gets the value of <a>PRINT_SETTINGS_N_COPIES</a>.
printSettingsGetNCopies :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_NUMBER_UP</a>.
printSettingsGetNumberUp :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_NUMBER_UP_LAYOUT</a>.
printSettingsGetNumberUpLayout :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m NumberUpLayout

-- | Get the value of <a>PRINT_SETTINGS_ORIENTATION</a>, converted to a
--   <tt>GtkPageOrientation</tt>.
printSettingsGetOrientation :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PageOrientation

-- | Gets the value of <a>PRINT_SETTINGS_OUTPUT_BIN</a>.
printSettingsGetOutputBin :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m (Maybe Text)

-- | Gets the value of <a>PRINT_SETTINGS_PAGE_RANGES</a>.
printSettingsGetPageRanges :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m [PageRange]

-- | Gets the value of <a>PRINT_SETTINGS_PAGE_SET</a>.
printSettingsGetPageSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PageSet

-- | Gets the value of <a>PRINT_SETTINGS_PAPER_HEIGHT</a>, converted to
--   <i><tt>unit</tt></i>.
printSettingsGetPaperHeight :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Unit -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_PAPER_FORMAT</a>, converted to a
--   <tt>GtkPaperSize</tt>.
printSettingsGetPaperSize :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m (Maybe PaperSize)

-- | Gets the value of <a>PRINT_SETTINGS_PAPER_WIDTH</a>, converted to
--   <i><tt>unit</tt></i>.
printSettingsGetPaperWidth :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Unit -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_PRINT_PAGES</a>.
printSettingsGetPrintPages :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintPages

-- | Convenience function to obtain the value of
--   <a>PRINT_SETTINGS_PRINTER</a>.
printSettingsGetPrinter :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m (Maybe Text)

-- | Gets the value of <a>PRINT_SETTINGS_PRINTER_LPI</a>.
printSettingsGetPrinterLpi :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_QUALITY</a>.
printSettingsGetQuality :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m PrintQuality

-- | Gets the value of <a>PRINT_SETTINGS_RESOLUTION</a>.
printSettingsGetResolution :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_RESOLUTION_X</a>.
printSettingsGetResolutionX :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_RESOLUTION_Y</a>.
printSettingsGetResolutionY :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Int32

-- | Gets the value of <a>PRINT_SETTINGS_REVERSE</a>.
printSettingsGetReverse :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Gets the value of <a>PRINT_SETTINGS_SCALE</a>.
printSettingsGetScale :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Double

-- | Gets the value of <a>PRINT_SETTINGS_USE_COLOR</a>.
printSettingsGetUseColor :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m Bool

-- | Returns <a>True</a>, if a value is associated with
--   <i><tt>key</tt></i>.
printSettingsHasKey :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m Bool

-- | Reads the print settings from <i><tt>fileName</tt></i>.
--   
--   If the file could not be loaded then error is set to either a
--   <tt>GFileError</tt> or <tt>GKeyFileError</tt>.
--   
--   See <a>printSettingsToFile</a>.
printSettingsLoadFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [Char] -> m ()

-- | Reads the print settings from the group <i><tt>groupName</tt></i> in
--   <i><tt>keyFile</tt></i>.
--   
--   If the file could not be loaded then error is set to either a
--   <tt>GFileError</tt> or <tt>GKeyFileError</tt>.
printSettingsLoadKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe Text -> m ()

-- | Creates a new <tt>GtkPrintSettings</tt> object.
printSettingsNew :: (HasCallStack, MonadIO m) => m PrintSettings

-- | Reads the print settings from <i><tt>fileName</tt></i>.
--   
--   Returns a new <tt>GtkPrintSettings</tt> object with the restored
--   settings, or <a>Nothing</a> if an error occurred. If the file could
--   not be loaded then error is set to either a <tt>GFileError</tt> or
--   <tt>GKeyFileError</tt>.
--   
--   See <a>printSettingsToFile</a>.
printSettingsNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m PrintSettings

-- | Deserialize print settings from an a{sv} variant.
--   
--   The variant must be in the format produced by
--   <a>printSettingsToGvariant</a>.
printSettingsNewFromGvariant :: (HasCallStack, MonadIO m) => GVariant -> m PrintSettings

-- | Reads the print settings from the group <i><tt>groupName</tt></i> in
--   <i><tt>keyFile</tt></i>.
--   
--   Returns a new <tt>GtkPrintSettings</tt> object with the restored
--   settings, or <a>Nothing</a> if an error occurred. If the file could
--   not be loaded then error is set to either <tt>GFileError</tt> or
--   <tt>GKeyFileError</tt>.
printSettingsNewFromKeyFile :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> m PrintSettings

-- | Associates <i><tt>value</tt></i> with <i><tt>key</tt></i>.
printSettingsSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Maybe Text -> m ()

-- | Sets <i><tt>key</tt></i> to a boolean value.
printSettingsSetBool :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Bool -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_COLLATE</a>.
printSettingsSetCollate :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_DEFAULT_SOURCE</a>.
printSettingsSetDefaultSource :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_DITHER</a>.
printSettingsSetDither :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets <i><tt>key</tt></i> to a double value.
printSettingsSetDouble :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_DUPLEX</a>.
printSettingsSetDuplex :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintDuplex -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_FINISHINGS</a>.
printSettingsSetFinishings :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets <i><tt>key</tt></i> to an integer value.
printSettingsSetInt :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Int32 -> m ()

-- | Associates a length in units of <i><tt>unit</tt></i> with
--   <i><tt>key</tt></i>.
printSettingsSetLength :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> Double -> Unit -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_MEDIA_TYPE</a>.
--   
--   The set of media types is defined in PWG 5101.1-2002 PWG.
printSettingsSetMediaType :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_N_COPIES</a>.
printSettingsSetNCopies :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_NUMBER_UP</a>.
printSettingsSetNumberUp :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_NUMBER_UP_LAYOUT</a>.
printSettingsSetNumberUpLayout :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> NumberUpLayout -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_ORIENTATION</a>.
printSettingsSetOrientation :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PageOrientation -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_OUTPUT_BIN</a>.
printSettingsSetOutputBin :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAGE_RANGES</a>.
printSettingsSetPageRanges :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [PageRange] -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAGE_SET</a>.
printSettingsSetPageSet :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PageSet -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAPER_HEIGHT</a>.
printSettingsSetPaperHeight :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> Unit -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAPER_FORMAT</a>,
--   <a>PRINT_SETTINGS_PAPER_WIDTH</a> and
--   <a>PRINT_SETTINGS_PAPER_HEIGHT</a>.
printSettingsSetPaperSize :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PaperSize -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PAPER_WIDTH</a>.
printSettingsSetPaperWidth :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> Unit -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PRINT_PAGES</a>.
printSettingsSetPrintPages :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintPages -> m ()

-- | Convenience function to set <a>PRINT_SETTINGS_PRINTER</a> to
--   <i><tt>printer</tt></i>.
printSettingsSetPrinter :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_PRINTER_LPI</a>.
printSettingsSetPrinterLpi :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_QUALITY</a>.
printSettingsSetQuality :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> PrintQuality -> m ()

-- | Sets the values of <a>PRINT_SETTINGS_RESOLUTION</a>,
--   <a>PRINT_SETTINGS_RESOLUTION_X</a> and
--   <a>PRINT_SETTINGS_RESOLUTION_Y</a>.
printSettingsSetResolution :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> m ()

-- | Sets the values of <a>PRINT_SETTINGS_RESOLUTION</a>,
--   <a>PRINT_SETTINGS_RESOLUTION_X</a> and
--   <a>PRINT_SETTINGS_RESOLUTION_Y</a>.
printSettingsSetResolutionXy :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Int32 -> Int32 -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_REVERSE</a>.
printSettingsSetReverse :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_SCALE</a>.
printSettingsSetScale :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Double -> m ()

-- | Sets the value of <a>PRINT_SETTINGS_USE_COLOR</a>.
printSettingsSetUseColor :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Bool -> m ()

-- | This function saves the print settings from <i><tt>settings</tt></i>
--   to <i><tt>fileName</tt></i>.
--   
--   If the file could not be written then error is set to either a
--   <tt>GFileError</tt> or <tt>GKeyFileError</tt>.
printSettingsToFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> [Char] -> m ()

-- | Serialize print settings to an a{sv} variant.
printSettingsToGvariant :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> m GVariant

-- | This function adds the print settings from <i><tt>settings</tt></i> to
--   <i><tt>keyFile</tt></i>.
printSettingsToKeyFile :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> KeyFile -> Maybe Text -> m ()

-- | Removes any value associated with <i><tt>key</tt></i>.
--   
--   This has the same effect as setting the value to <a>Nothing</a>.
printSettingsUnset :: (HasCallStack, MonadIO m, IsPrintSettings a) => a -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PrintSettings.PrintSettings
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PrintSettings.PrintSettings
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PrintSettings.PrintSettings
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PrintSettings.PrintSettings)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PrintSettings.PrintSettings o) => GI.Gtk.Objects.PrintSettings.IsPrintSettings o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PrintSettings.PrintSettings
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PrintSettings.PrintSettings


-- | High-level, portable printing API.
--   
--   It looks a bit different than other GTK dialogs such as the
--   <tt>GtkFileChooser</tt>, since some platforms don’t expose enough
--   infrastructure to implement a good print dialog. On such platforms,
--   <tt>GtkPrintOperation</tt> uses the native print dialog. On platforms
--   which do not provide a native print dialog, GTK uses its own, see
--   <a>PrintUnixDialog</a>.
--   
--   The typical way to use the high-level printing API is to create a
--   <tt>GtkPrintOperation</tt> object with <a>printOperationNew</a> when
--   the user selects to print. Then you set some properties on it, e.g.
--   the page size, any <a>PrintSettings</a> from previous print
--   operations, the number of pages, the current page, etc.
--   
--   Then you start the print operation by calling
--   <a>printOperationRun</a>. It will then show a dialog, let the user
--   select a printer and options. When the user finished the dialog,
--   various signals will be emitted on the <tt>GtkPrintOperation</tt>, the
--   main one being <a>PrintOperation::drawPage</a>, which you are supposed
--   to handle and render the page on the provided <a>PrintContext</a>
--   using Cairo.
--   
--   <h1>The high-level printing API</h1>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static GtkPrintSettings *settings = NULL;
--   
--   static void
--   do_print (void)
--   {
--     GtkPrintOperation *print;
--     GtkPrintOperationResult res;
--   
--     print = gtk_print_operation_new ();
--   
--     if (settings != NULL)
--       gtk_print_operation_set_print_settings (print, settings);
--   
--     g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), NULL);
--     g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL);
--   
--     res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
--                                    GTK_WINDOW (main_window), NULL);
--   
--     if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
--       {
--         if (settings != NULL)
--           g_object_unref (settings);
--         settings = g_object_ref (gtk_print_operation_get_print_settings (print));
--       }
--   
--     g_object_unref (print);
--   }
--   </pre>
--   
--   By default <tt>GtkPrintOperation</tt> uses an external application to
--   do print preview. To implement a custom print preview, an application
--   must connect to the preview signal. The functions
--   <a>printOperationPreviewRenderPage</a>,
--   <a>printOperationPreviewEndPreview</a> and
--   <a>printOperationPreviewIsSelected</a> are useful when implementing a
--   print preview.
module GI.Gtk.Objects.PrintOperation

-- | Memory-managed wrapper type.
newtype PrintOperation
PrintOperation :: ManagedPtr PrintOperation -> PrintOperation

-- | Type class for types which can be safely cast to
--   <a>PrintOperation</a>, for instance with <a>toPrintOperation</a>.
class (GObject o, IsDescendantOf PrintOperation o) => IsPrintOperation o

-- | Cast to <a>PrintOperation</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPrintOperation :: (MonadIO m, IsPrintOperation o) => o -> m PrintOperation

-- | Cancels a running print operation.
--   
--   This function may be called from a <a>PrintOperation::beginPrint</a>,
--   <a>PrintOperation::paginate</a> or <a>PrintOperation::drawPage</a>
--   signal handler to stop the currently running print operation.
printOperationCancel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Signal that drawing of particular page is complete.
--   
--   It is called after completion of page drawing (e.g. drawing in another
--   thread). If <a>printOperationSetDeferDrawing</a> was called before,
--   then this function has to be called by application. Otherwise it is
--   called by GTK itself.
printOperationDrawPageFinish :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Returns the default page setup.
printOperationGetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m (Maybe PageSetup)

-- | Gets whether page setup selection combos are embedded
printOperationGetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Call this when the result of a print operation is
--   <a>PrintOperationResultError</a>.
--   
--   It can be called either after <a>printOperationRun</a> returns, or in
--   the <a>PrintOperation::done</a> signal handler.
--   
--   The returned <tt>GError</tt> will contain more details on what went
--   wrong.
printOperationGetError :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Gets whether there is a selection.
printOperationGetHasSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Returns the number of pages that will be printed.
--   
--   Note that this value is set during print preparation phase
--   (<a>PrintStatusPreparing</a>), so this function should never be called
--   before the data generation phase (<a>PrintStatusGeneratingData</a>).
--   You can connect to the <a>PrintOperation::statusChanged</a> signal and
--   call <a>printOperationGetNPagesToPrint</a> when print status is
--   <a>PrintStatusGeneratingData</a>.
--   
--   This is typically used to track the progress of print operation.
printOperationGetNPagesToPrint :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Int32

-- | Returns the current print settings.
--   
--   Note that the return value is <a>Nothing</a> until either
--   <a>printOperationSetPrintSettings</a> or <a>printOperationRun</a> have
--   been called.
printOperationGetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m (Maybe PrintSettings)

-- | Returns the status of the print operation.
--   
--   Also see <a>printOperationGetStatusString</a>.
printOperationGetStatus :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m PrintStatus

-- | Returns a string representation of the status of the print operation.
--   
--   The string is translated and suitable for displaying the print status
--   e.g. in a <tt>GtkStatusbar</tt>.
--   
--   Use <a>printOperationGetStatus</a> to obtain a status value that is
--   suitable for programmatic use.
printOperationGetStatusString :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Text

-- | Gets whether the application supports print of selection
printOperationGetSupportSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | A convenience function to find out if the print operation is finished.
--   
--   a print operation is finished if its status is either
--   <a>PrintStatusFinished</a> or <a>PrintStatusFinishedAborted</a>.
--   
--   Note: when you enable print status tracking the print operation can be
--   in a non-finished state even after done has been called, as the
--   operation status then tracks the print job status on the printer.
printOperationIsFinished :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m Bool

-- | Creates a new <tt>GtkPrintOperation</tt>.
printOperationNew :: (HasCallStack, MonadIO m) => m PrintOperation

-- | Runs the print operation.
--   
--   Normally that this function does not return until the rendering of all
--   pages is complete. You can connect to the
--   <a>PrintOperation::statusChanged</a> signal on <i><tt>op</tt></i> to
--   obtain some information about the progress of the print operation.
--   
--   Furthermore, it may use a recursive mainloop to show the print dialog.
--   
--   If you set the [Gtk.PrintOperation:allow-async] property, the
--   operation will run asynchronously if this is supported on the
--   platform. The <a>PrintOperation::done</a> signal will be emitted with
--   the result of the operation when the it is done (i.e. when the dialog
--   is canceled, or when the print succeeds or fails).
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   if (settings != NULL)
--     gtk_print_operation_set_print_settings (print, settings);
--   
--   if (page_setup != NULL)
--     gtk_print_operation_set_default_page_setup (print, page_setup);
--   
--   g_signal_connect (print, "begin-print",
--                     G_CALLBACK (begin_print), &amp;data);
--   g_signal_connect (print, "draw-page",
--                     G_CALLBACK (draw_page), &amp;data);
--   
--   res = gtk_print_operation_run (print,
--                                  GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
--                                  parent,
--                                  &amp;error);
--   
--   if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
--    {
--      error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
--     			                     GTK_DIALOG_DESTROY_WITH_PARENT,
--   					     GTK_MESSAGE_ERROR,
--   					     GTK_BUTTONS_CLOSE,
--   					     "Error printing file:\n%s",
--   					     error-&gt;message);
--      g_signal_connect (error_dialog, "response",
--                        G_CALLBACK (gtk_window_destroy), NULL);
--      gtk_window_present (GTK_WINDOW (error_dialog));
--      g_error_free (error);
--    }
--   else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
--    {
--      if (settings != NULL)
--   g_object_unref (settings);
--      settings = g_object_ref (gtk_print_operation_get_print_settings (print));
--    }
--   </pre>
--   
--   Note that <a>printOperationRun</a> can only be called once on a given
--   <tt>GtkPrintOperation</tt>.
printOperationRun :: (HasCallStack, MonadIO m, IsPrintOperation a, IsWindow b) => a -> PrintOperationAction -> Maybe b -> m PrintOperationResult

-- | Sets whether <a>printOperationRun</a> may return before the print
--   operation is completed.
--   
--   Note that some platforms may not allow asynchronous operation.
printOperationSetAllowAsync :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets the current page.
--   
--   If this is called before <a>printOperationRun</a>, the user will be
--   able to select to print only the current page.
--   
--   Note that this only makes sense for pre-paginated documents.
printOperationSetCurrentPage :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Int32 -> m ()

-- | Sets the label for the tab holding custom widgets.
printOperationSetCustomTabLabel :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Maybe Text -> m ()

-- | Makes <i><tt>defaultPageSetup</tt></i> the default page setup for
--   <i><tt>op</tt></i>.
--   
--   This page setup will be used by <a>printOperationRun</a>, but it can
--   be overridden on a per-page basis by connecting to the
--   <a>PrintOperation::requestPageSetup</a> signal.
printOperationSetDefaultPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPageSetup b) => a -> Maybe b -> m ()

-- | Sets up the <tt>GtkPrintOperation</tt> to wait for calling of
--   [method<i><tt>gtk</tt></i>.PrintOperation.draw_page_finish from
--   application.
--   
--   This can be used for drawing page in another thread.
--   
--   This function must be called in the callback of the
--   <a>PrintOperation::drawPage</a> signal.
printOperationSetDeferDrawing :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> m ()

-- | Embed page size combo box and orientation combo box into page setup
--   page.
--   
--   Selected page setup is stored as default page setup in
--   <tt>GtkPrintOperation</tt>.
printOperationSetEmbedPageSetup :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets up the <tt>GtkPrintOperation</tt> to generate a file instead of
--   showing the print dialog.
--   
--   The intended use of this function is for implementing “Export to PDF”
--   actions. Currently, PDF is the only supported format.
--   
--   “Print to PDF” support is independent of this and is done by letting
--   the user pick the “Print to PDF” item from the list of printers in the
--   print dialog.
printOperationSetExportFilename :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> [Char] -> m ()

-- | Sets whether there is a selection to print.
--   
--   Application has to set number of pages to which the selection will
--   draw by <a>printOperationSetNPages</a> in a handler for the
--   <a>PrintOperation::beginPrint</a> signal.
printOperationSetHasSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets the name of the print job.
--   
--   The name is used to identify the job (e.g. in monitoring applications
--   like eggcups).
--   
--   If you don’t set a job name, GTK picks a default one by numbering
--   successive print jobs.
printOperationSetJobName :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Text -> m ()

-- | Sets the number of pages in the document.
--   
--   This must be set to a positive number before the rendering starts. It
--   may be set in a <a>PrintOperation::beginPrint</a> signal handler.
--   
--   Note that the page numbers passed to the
--   <a>PrintOperation::requestPageSetup</a> and
--   <a>PrintOperation::drawPage</a> signals are 0-based, i.e. if the user
--   chooses to print all pages, the last <a>drawPage</a> signal will be
--   for page <i><tt>nPages</tt></i> - 1.
printOperationSetNPages :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Int32 -> m ()

-- | Sets the print settings for <i><tt>op</tt></i>.
--   
--   This is typically used to re-establish print settings from a previous
--   print operation, see <a>printOperationRun</a>.
printOperationSetPrintSettings :: (HasCallStack, MonadIO m, IsPrintOperation a, IsPrintSettings b) => a -> Maybe b -> m ()

-- | If <i><tt>showProgress</tt></i> is <a>True</a>, the print operation
--   will show a progress dialog during the print operation.
printOperationSetShowProgress :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets whether selection is supported by <tt>GtkPrintOperation</tt>.
printOperationSetSupportSelection :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | If track_status is <a>True</a>, the print operation will try to
--   continue report on the status of the print job in the printer queues
--   and printer.
--   
--   This can allow your application to show things like “out of paper”
--   issues, and when the print job actually reaches the printer.
--   
--   This function is often implemented using some form of polling, so it
--   should not be enabled unless needed.
printOperationSetTrackPrintStatus :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Sets up the transformation for the cairo context obtained from
--   <tt>GtkPrintContext</tt> in such a way that distances are measured in
--   units of <i><tt>unit</tt></i>.
printOperationSetUnit :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Unit -> m ()

-- | If <i><tt>fullPage</tt></i> is <a>True</a>, the transformation for the
--   cairo context obtained from <tt>GtkPrintContext</tt> puts the origin
--   at the top left corner of the page.
--   
--   This may not be the top left corner of the sheet, depending on page
--   orientation and the number of pages per sheet). Otherwise, the origin
--   is at the top left corner of the imageable area (i.e. inside the
--   margins).
printOperationSetUseFullPage :: (HasCallStack, MonadIO m, IsPrintOperation a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>allow-async</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationAllowAsync :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>allow-async</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #allowAsync
--   </pre>
getPrintOperationAllowAsync :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>allow-async</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #allowAsync <a>:=</a> value ]
--   </pre>
setPrintOperationAllowAsync :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>current-page</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationCurrentPage :: (IsPrintOperation o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>current-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #currentPage
--   </pre>
getPrintOperationCurrentPage :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Set the value of the “<tt>current-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #currentPage <a>:=</a> value ]
--   </pre>
setPrintOperationCurrentPage :: (MonadIO m, IsPrintOperation o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>custom-tab-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #customTabLabel
--   </pre>
clearPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>custom-tab-label</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationCustomTabLabel :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>custom-tab-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #customTabLabel
--   </pre>
getPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>custom-tab-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #customTabLabel <a>:=</a> value ]
--   </pre>
setPrintOperationCustomTabLabel :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Set the value of the “<tt>default-page-setup</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #defaultPageSetup
--   </pre>
clearPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-page-setup</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPrintOperationDefaultPageSetup :: (IsPrintOperation o, MonadIO m, IsPageSetup a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #defaultPageSetup
--   </pre>
getPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe PageSetup)

-- | Set the value of the “<tt>default-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #defaultPageSetup <a>:=</a> value ]
--   </pre>
setPrintOperationDefaultPageSetup :: (MonadIO m, IsPrintOperation o, IsPageSetup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>embed-page-setup</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationEmbedPageSetup :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>embed-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #embedPageSetup
--   </pre>
getPrintOperationEmbedPageSetup :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>embed-page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #embedPageSetup <a>:=</a> value ]
--   </pre>
setPrintOperationEmbedPageSetup :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Set the value of the “<tt>export-filename</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #exportFilename
--   </pre>
clearPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>export-filename</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationExportFilename :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>export-filename</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #exportFilename
--   </pre>
getPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>export-filename</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #exportFilename <a>:=</a> value ]
--   </pre>
setPrintOperationExportFilename :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-selection</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationHasSelection :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #hasSelection
--   </pre>
getPrintOperationHasSelection :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>has-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #hasSelection <a>:=</a> value ]
--   </pre>
setPrintOperationHasSelection :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>job-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrintOperationJobName :: (IsPrintOperation o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>job-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #jobName
--   </pre>
getPrintOperationJobName :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>job-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #jobName <a>:=</a> value ]
--   </pre>
setPrintOperationJobName :: (MonadIO m, IsPrintOperation o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-pages</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintOperationNPages :: (IsPrintOperation o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-pages</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #nPages
--   </pre>
getPrintOperationNPages :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Set the value of the “<tt>n-pages</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #nPages <a>:=</a> value ]
--   </pre>
setPrintOperationNPages :: (MonadIO m, IsPrintOperation o) => o -> Int32 -> m ()

-- | Get the value of the “<tt>n-pages-to-print</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #nPagesToPrint
--   </pre>
getPrintOperationNPagesToPrint :: (MonadIO m, IsPrintOperation o) => o -> m Int32

-- | Set the value of the “<tt>print-settings</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #printSettings
--   </pre>
clearPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>print-settings</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationPrintSettings :: (IsPrintOperation o, MonadIO m, IsPrintSettings a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #printSettings
--   </pre>
getPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o) => o -> m (Maybe PrintSettings)

-- | Set the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #printSettings <a>:=</a> value ]
--   </pre>
setPrintOperationPrintSettings :: (MonadIO m, IsPrintOperation o, IsPrintSettings a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-progress</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationShowProgress :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-progress</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #showProgress
--   </pre>
getPrintOperationShowProgress :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>show-progress</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #showProgress <a>:=</a> value ]
--   </pre>
setPrintOperationShowProgress :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Get the value of the “<tt>status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #status
--   </pre>
getPrintOperationStatus :: (MonadIO m, IsPrintOperation o) => o -> m PrintStatus

-- | Get the value of the “<tt>status-string</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #statusString
--   </pre>
getPrintOperationStatusString :: (MonadIO m, IsPrintOperation o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>support-selection</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintOperationSupportSelection :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>support-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #supportSelection
--   </pre>
getPrintOperationSupportSelection :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>support-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #supportSelection <a>:=</a> value ]
--   </pre>
setPrintOperationSupportSelection :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>track-print-status</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPrintOperationTrackPrintStatus :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>track-print-status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #trackPrintStatus
--   </pre>
getPrintOperationTrackPrintStatus :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>track-print-status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #trackPrintStatus <a>:=</a> value ]
--   </pre>
setPrintOperationTrackPrintStatus :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>unit</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintOperationUnit :: (IsPrintOperation o, MonadIO m) => Unit -> m (GValueConstruct o)

-- | Get the value of the “<tt>unit</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #unit
--   </pre>
getPrintOperationUnit :: (MonadIO m, IsPrintOperation o) => o -> m Unit

-- | Set the value of the “<tt>unit</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #unit <a>:=</a> value ]
--   </pre>
setPrintOperationUnit :: (MonadIO m, IsPrintOperation o) => o -> Unit -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-full-page</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintOperationUseFullPage :: (IsPrintOperation o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-full-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printOperation #useFullPage
--   </pre>
getPrintOperationUseFullPage :: (MonadIO m, IsPrintOperation o) => o -> m Bool

-- | Set the value of the “<tt>use-full-page</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printOperation [ #useFullPage <a>:=</a> value ]
--   </pre>
setPrintOperationUseFullPage :: (MonadIO m, IsPrintOperation o) => o -> Bool -> m ()

-- | Emitted after the user has finished changing print settings in the
--   dialog, before the actual rendering starts.
--   
--   A typical use for <a>beginPrint</a> is to use the parameters from the
--   <a>PrintContext</a> and paginate the document accordingly, and then
--   set the number of pages with <a>printOperationSetNPages</a>.
type PrintOperationBeginPrintCallback = PrintContext -> IO ()

-- | Connect a signal handler for the <a>beginPrint</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #beginPrint callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationBeginPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationBeginPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>beginPrint</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #beginPrint callback
--   </pre>
onPrintOperationBeginPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationBeginPrintCallback) -> m SignalHandlerId

-- | Emitted when displaying the print dialog.
--   
--   If you return a widget in a handler for this signal it will be added
--   to a custom tab in the print dialog. You typically return a container
--   widget with multiple widgets in it.
--   
--   The print dialog owns the returned widget, and its lifetime is not
--   controlled by the application. However, the widget is guaranteed to
--   stay around until the <a>PrintOperation::customWidgetApply</a> signal
--   is emitted on the operation. Then you can read out any information you
--   need from the widgets.
type PrintOperationCreateCustomWidgetCallback = IO Maybe Object

-- | Connect a signal handler for the <a>createCustomWidget</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #createCustomWidget callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCreateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createCustomWidget</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #createCustomWidget callback
--   </pre>
onPrintOperationCreateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCreateCustomWidgetCallback) -> m SignalHandlerId

-- | Emitted right before <a>beginPrint</a> if you added a custom widget in
--   the <a>createCustomWidget</a> handler.
--   
--   When you get this signal you should read the information from the
--   custom widgets, as the widgets are not guaranteed to be around at a
--   later time.
type PrintOperationCustomWidgetApplyCallback = Widget -> IO ()

-- | Connect a signal handler for the <a>customWidgetApply</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #customWidgetApply callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationCustomWidgetApply :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCustomWidgetApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>customWidgetApply</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #customWidgetApply callback
--   </pre>
onPrintOperationCustomWidgetApply :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationCustomWidgetApplyCallback) -> m SignalHandlerId

-- | Emitted when the print operation run has finished doing everything
--   required for printing.
--   
--   <i><tt>result</tt></i> gives you information about what happened
--   during the run. If <i><tt>result</tt></i> is
--   <a>PrintOperationResultError</a> then you can call
--   <a>printOperationGetError</a> for more information.
--   
--   If you enabled print status tracking then
--   <a>printOperationIsFinished</a> may still return <a>False</a> after
--   the <a>done</a> signal was emitted.
type PrintOperationDoneCallback = PrintOperationResult -> IO ()

-- | Connect a signal handler for the <a>done</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #done callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationDone :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>done</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #done callback
--   </pre>
onPrintOperationDone :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDoneCallback) -> m SignalHandlerId

-- | Emitted for every page that is printed.
--   
--   The signal handler must render the <i><tt>pageNr</tt></i>'s page onto
--   the cairo context obtained from <i><tt>context</tt></i> using
--   <a>printContextGetCairoContext</a>.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   draw_page (GtkPrintOperation *operation,
--              GtkPrintContext   *context,
--              int                page_nr,
--              gpointer           user_data)
--   {
--     cairo_t *cr;
--     PangoLayout *layout;
--     double width, text_height;
--     int layout_height;
--     PangoFontDescription *desc;
--     
--     cr = gtk_print_context_get_cairo_context (context);
--     width = gtk_print_context_get_width (context);
--     
--     cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT);
--     
--     cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
--     cairo_fill (cr);
--     
--     layout = gtk_print_context_create_pango_layout (context);
--     
--     desc = pango_font_description_from_string ("sans 14");
--     pango_layout_set_font_description (layout, desc);
--     pango_font_description_free (desc);
--     
--     pango_layout_set_text (layout, "some text", -1);
--     pango_layout_set_width (layout, width * PANGO_SCALE);
--     pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
--        		      
--     pango_layout_get_size (layout, NULL, &amp;layout_height);
--     text_height = (double)layout_height / PANGO_SCALE;
--     
--     cairo_move_to (cr, width / 2,  (HEADER_HEIGHT - text_height) / 2);
--     pango_cairo_show_layout (cr, layout);
--     
--     g_object_unref (layout);
--   }
--   </pre>
--   
--   Use <a>printOperationSetUseFullPage</a> and
--   <a>printOperationSetUnit</a> before starting the print operation to
--   set up the transformation of the cairo context according to your
--   needs.
type PrintOperationDrawPageCallback = PrintContext -> Int32 -> IO ()

-- | Connect a signal handler for the <a>drawPage</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #drawPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationDrawPage :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDrawPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>drawPage</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #drawPage callback
--   </pre>
onPrintOperationDrawPage :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationDrawPageCallback) -> m SignalHandlerId

-- | Emitted after all pages have been rendered.
--   
--   A handler for this signal can clean up any resources that have been
--   allocated in the <a>PrintOperation::beginPrint</a> handler.
type PrintOperationEndPrintCallback = PrintContext -> IO ()

-- | Connect a signal handler for the <a>endPrint</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #endPrint callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationEndPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationEndPrintCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>endPrint</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #endPrint callback
--   </pre>
onPrintOperationEndPrint :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationEndPrintCallback) -> m SignalHandlerId

-- | Emitted after the <a>beginPrint</a> signal, but before the actual
--   rendering starts.
--   
--   It keeps getting emitted until a connected signal handler returns
--   <a>True</a>.
--   
--   The <a>paginate</a> signal is intended to be used for paginating a
--   document in small chunks, to avoid blocking the user interface for a
--   long time. The signal handler should update the number of pages using
--   <a>printOperationSetNPages</a>, and return <a>True</a> if the document
--   has been completely paginated.
--   
--   If you don't need to do pagination in chunks, you can simply do it all
--   in the <a>beginPrint</a> handler, and set the number of pages from
--   there.
type PrintOperationPaginateCallback = PrintContext -> IO Bool

-- | Connect a signal handler for the <a>paginate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #paginate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPaginate :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPaginateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>paginate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #paginate callback
--   </pre>
onPrintOperationPaginate :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPaginateCallback) -> m SignalHandlerId

-- | Gets emitted when a preview is requested from the native dialog.
--   
--   The default handler for this signal uses an external viewer
--   application to preview.
--   
--   To implement a custom print preview, an application must return
--   <a>True</a> from its handler for this signal. In order to use the
--   provided <i><tt>context</tt></i> for the preview implementation, it
--   must be given a suitable cairo context with
--   <a>printContextSetCairoContext</a>.
--   
--   The custom preview implementation can use
--   <a>printOperationPreviewIsSelected</a> and
--   <a>printOperationPreviewRenderPage</a> to find pages which are
--   selected for print and render them. The preview must be finished by
--   calling <a>printOperationPreviewEndPreview</a> (typically in response
--   to the user clicking a close button).
type PrintOperationPreviewCallback = PrintOperationPreview -> PrintContext -> Maybe Window -> IO Bool

-- | Connect a signal handler for the <a>preview</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #preview callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationPreview :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preview</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #preview callback
--   </pre>
onPrintOperationPreview :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationPreviewCallback) -> m SignalHandlerId

-- | Emitted once for every page that is printed.
--   
--   This gives the application a chance to modify the page setup. Any
--   changes done to <i><tt>setup</tt></i> will be in force only for
--   printing this page.
type PrintOperationRequestPageSetupCallback = PrintContext -> Int32 -> PageSetup -> IO ()

-- | Connect a signal handler for the <a>requestPageSetup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #requestPageSetup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationRequestPageSetup :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationRequestPageSetupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>requestPageSetup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #requestPageSetup callback
--   </pre>
onPrintOperationRequestPageSetup :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationRequestPageSetupCallback) -> m SignalHandlerId

-- | Emitted at between the various phases of the print operation.
--   
--   See <a>PrintStatus</a> for the phases that are being discriminated.
--   Use <a>printOperationGetStatus</a> to find out the current status.
type PrintOperationStatusChangedCallback = IO ()

-- | Connect a signal handler for the <a>statusChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #statusChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationStatusChanged :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationStatusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>statusChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #statusChanged callback
--   </pre>
onPrintOperationStatusChanged :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationStatusChangedCallback) -> m SignalHandlerId

-- | Emitted after change of selected printer.
--   
--   The actual page setup and print settings are passed to the custom
--   widget, which can actualize itself according to this change.
type PrintOperationUpdateCustomWidgetCallback = Widget -> PageSetup -> PrintSettings -> IO ()

-- | Connect a signal handler for the <a>updateCustomWidget</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printOperation #updateCustomWidget callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintOperationUpdateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationUpdateCustomWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>updateCustomWidget</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printOperation #updateCustomWidget callback
--   </pre>
onPrintOperationUpdateCustomWidget :: (IsPrintOperation a, MonadIO m) => a -> ((?self :: a) => PrintOperationUpdateCustomWidgetCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.PrintOperation.PrintOperation
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PrintOperation.PrintOperation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PrintOperation.PrintOperation
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PrintOperation.PrintOperation)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PrintOperation.PrintOperation o) => GI.Gtk.Objects.PrintOperation.IsPrintOperation o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PrintOperation.PrintOperation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PrintOperation.PrintOperation


-- | Represents a job that is sent to a printer.
--   
--   You only need to deal directly with print jobs if you use the
--   non-portable <a>PrintUnixDialog</a> API.
--   
--   Use <a>printJobGetSurface</a> to obtain the cairo surface onto which
--   the pages must be drawn. Use <a>printJobSend</a> to send the finished
--   job to the printer. If you don’t use cairo <tt>GtkPrintJob</tt> also
--   supports printing of manually generated PostScript, via
--   <a>printJobSetSourceFile</a>.
module GI.Gtk.Objects.PrintJob

-- | Memory-managed wrapper type.
newtype PrintJob
PrintJob :: ManagedPtr PrintJob -> PrintJob

-- | Type class for types which can be safely cast to <a>PrintJob</a>, for
--   instance with <a>toPrintJob</a>.
class (GObject o, IsDescendantOf PrintJob o) => IsPrintJob o

-- | Cast to <a>PrintJob</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toPrintJob :: (MonadIO m, IsPrintJob o) => o -> m PrintJob

-- | Gets whether this job is printed collated.
printJobGetCollate :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Bool

-- | Gets the n-up setting for this job.
printJobGetNUp :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Word32

-- | Gets the n-up layout setting for this job.
printJobGetNUpLayout :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m NumberUpLayout

-- | Gets the number of copies of this job.
printJobGetNumCopies :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Int32

-- | Gets the page ranges for this job.
printJobGetPageRanges :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m [PageRange]

-- | Gets the <tt>GtkPageSet</tt> setting for this job.
printJobGetPageSet :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m PageSet

-- | Gets the <tt>GtkPrintPages</tt> setting for this job.
printJobGetPages :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m PrintPages

-- | Gets the <tt>GtkPrinter</tt> of the print job.
printJobGetPrinter :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Printer

-- | Gets whether this job is printed reversed.
printJobGetReverse :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Bool

-- | Gets whether the job is printed rotated.
printJobGetRotate :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Bool

-- | Gets the scale for this job.
printJobGetScale :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Double

-- | Gets the <tt>GtkPrintSettings</tt> of the print job.
printJobGetSettings :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m PrintSettings

-- | Gets the status of the print job.
printJobGetStatus :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m PrintStatus

-- | Gets a cairo surface onto which the pages of the print job should be
--   rendered.
printJobGetSurface :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Surface

-- | Gets the job title.
printJobGetTitle :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Text

-- | Returns whether jobs will be tracked after printing.
--   
--   For details, see <a>printJobSetTrackPrintStatus</a>.
printJobGetTrackPrintStatus :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> m Bool

-- | Creates a new <tt>GtkPrintJob</tt>.
printJobNew :: (HasCallStack, MonadIO m, IsPrinter a, IsPrintSettings b, IsPageSetup c) => Text -> a -> b -> c -> m PrintJob

-- | Sends the print job off to the printer.
printJobSend :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> PrintJobCompleteFunc -> m ()

-- | Sets whether this job is printed collated.
printJobSetCollate :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Bool -> m ()

-- | Sets the n-up setting for this job.
printJobSetNUp :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Word32 -> m ()

-- | Sets the n-up layout setting for this job.
printJobSetNUpLayout :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> NumberUpLayout -> m ()

-- | Sets the number of copies for this job.
printJobSetNumCopies :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Int32 -> m ()

-- | Sets the page ranges for this job.
printJobSetPageRanges :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> [PageRange] -> m ()

-- | Sets the <tt>GtkPageSet</tt> setting for this job.
printJobSetPageSet :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> PageSet -> m ()

-- | Sets the <tt>GtkPrintPages</tt> setting for this job.
printJobSetPages :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> PrintPages -> m ()

-- | Sets whether this job is printed reversed.
printJobSetReverse :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Bool -> m ()

-- | Sets whether this job is printed rotated.
printJobSetRotate :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Bool -> m ()

-- | Sets the scale for this job.
--   
--   <ol>
--   <li>0 means unscaled.</li>
--   </ol>
printJobSetScale :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Double -> m ()

-- | Make the <tt>GtkPrintJob</tt> send an existing document to the
--   printing system.
--   
--   The file can be in any format understood by the platforms printing
--   system (typically PostScript, but on many platforms PDF may work too).
--   See <a>printerAcceptsPdf</a> and <a>printerAcceptsPs</a>.
--   
--   This is similar to <a>printJobSetSourceFile</a>, but takes expects an
--   open file descriptor for the file, instead of a filename.
printJobSetSourceFd :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Int32 -> m ()

-- | Make the <tt>GtkPrintJob</tt> send an existing document to the
--   printing system.
--   
--   The file can be in any format understood by the platforms printing
--   system (typically PostScript, but on many platforms PDF may work too).
--   See <a>printerAcceptsPdf</a> and <a>printerAcceptsPs</a>.
printJobSetSourceFile :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> [Char] -> m ()

-- | If track_status is <a>True</a>, the print job will try to continue
--   report on the status of the print job in the printer queues and
--   printer.
--   
--   This can allow your application to show things like “out of paper”
--   issues, and when the print job actually reaches the printer.
--   
--   This function is often implemented using some form of polling, so it
--   should not be enabled unless needed.
printJobSetTrackPrintStatus :: (HasCallStack, MonadIO m, IsPrintJob a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-setup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrintJobPageSetup :: (IsPrintJob o, MonadIO m, IsPageSetup a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printJob #pageSetup
--   </pre>
getPrintJobPageSetup :: (MonadIO m, IsPrintJob o) => o -> m (Maybe PageSetup)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>printer</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintJobPrinter :: (IsPrintJob o, MonadIO m, IsPrinter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>printer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printJob #printer
--   </pre>
getPrintJobPrinter :: (MonadIO m, IsPrintJob o) => o -> m Printer

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>settings</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrintJobSettings :: (IsPrintJob o, MonadIO m, IsPrintSettings a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printJob #settings
--   </pre>
getPrintJobSettings :: (MonadIO m, IsPrintJob o) => o -> m PrintSettings

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintJobTitle :: (IsPrintJob o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printJob #title
--   </pre>
getPrintJobTitle :: (MonadIO m, IsPrintJob o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>track-print-status</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPrintJobTrackPrintStatus :: (IsPrintJob o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>track-print-status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printJob #trackPrintStatus
--   </pre>
getPrintJobTrackPrintStatus :: (MonadIO m, IsPrintJob o) => o -> m Bool

-- | Set the value of the “<tt>track-print-status</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printJob [ #trackPrintStatus <a>:=</a> value ]
--   </pre>
setPrintJobTrackPrintStatus :: (MonadIO m, IsPrintJob o) => o -> Bool -> m ()

-- | Emitted when the status of a job changes.
--   
--   The signal handler can use <a>printJobGetStatus</a> to obtain the new
--   status.
type PrintJobStatusChangedCallback = IO ()

-- | Connect a signal handler for the <a>statusChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> printJob #statusChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPrintJobStatusChanged :: (IsPrintJob a, MonadIO m) => a -> ((?self :: a) => PrintJobStatusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>statusChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> printJob #statusChanged callback
--   </pre>
onPrintJobStatusChanged :: (IsPrintJob a, MonadIO m) => a -> ((?self :: a) => PrintJobStatusChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.PrintJob.PrintJob
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PrintJob.PrintJob
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PrintJob.PrintJob
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PrintJob.PrintJob)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PrintJob.PrintJob o) => GI.Gtk.Objects.PrintJob.IsPrintJob o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PrintJob.PrintJob
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PrintJob.PrintJob


-- | Asynchronous API to present a print dialog to the user.
--   
--   <tt>GtkPrintDialog</tt> collects the arguments that are needed to
--   present the dialog, such as a title for the dialog and whether it
--   should be modal.
--   
--   The dialog is shown with the <a>printDialogSetup</a> function.
--   
--   The actual printing can be done with <a>printDialogPrint</a> or
--   <a>printDialogPrintFile</a>. These APIs follows the GIO async pattern,
--   and the results can be obtained by calling the corresponding finish
--   methods.
--   
--   <i>Since: 4.14</i>
module GI.Gtk.Objects.PrintDialog

-- | Memory-managed wrapper type.
newtype PrintDialog
PrintDialog :: ManagedPtr PrintDialog -> PrintDialog

-- | Type class for types which can be safely cast to <a>PrintDialog</a>,
--   for instance with <a>toPrintDialog</a>.
class (GObject o, IsDescendantOf PrintDialog o) => IsPrintDialog o

-- | Cast to <a>PrintDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPrintDialog :: (MonadIO m, IsPrintDialog o) => o -> m PrintDialog

-- | Returns the label that will be shown on the accept button of the print
--   dialog.
--   
--   <i>Since: 4.14</i>
printDialogGetAcceptLabel :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> m Text

-- | Returns whether the print dialog blocks interaction with the parent
--   window while it is presented.
--   
--   <i>Since: 4.14</i>
printDialogGetModal :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> m Bool

-- | Returns the page setup.
--   
--   <i>Since: 4.14</i>
printDialogGetPageSetup :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> m (Maybe PageSetup)

-- | Returns the print settings for the print dialog.
--   
--   <i>Since: 4.14</i>
printDialogGetPrintSettings :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> m (Maybe PrintSettings)

-- | Returns the title that will be shown on the print dialog.
--   
--   <i>Since: 4.14</i>
printDialogGetTitle :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> m Text

-- | Creates a new <tt>GtkPrintDialog</tt> object.
--   
--   <i>Since: 4.14</i>
printDialogNew :: (HasCallStack, MonadIO m) => m PrintDialog

-- | This function prints content from a stream.
--   
--   If you pass <tt>NULL</tt> as <i><tt>setup</tt></i>, then this method
--   will present a print dialog. Otherwise, it will attempt to print
--   directly, without user interaction.
--   
--   The <i><tt>callback</tt></i> will be called when the printing is done.
--   
--   <i>Since: 4.14</i>
printDialogPrint :: (HasCallStack, MonadIO m, IsPrintDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe PrintSetup -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | This function prints a file.
--   
--   If you pass <tt>NULL</tt> as <i><tt>setup</tt></i>, then this method
--   will present a print dialog. Otherwise, it will attempt to print
--   directly, without user interaction.
--   
--   <i>Since: 4.14</i>
printDialogPrintFile :: (HasCallStack, MonadIO m, IsPrintDialog a, IsWindow b, IsFile c, IsCancellable d) => a -> Maybe b -> Maybe PrintSetup -> c -> Maybe d -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>printDialogPrintFile</a> call and returns the results.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.14</i>
printDialogPrintFileFinish :: (HasCallStack, MonadIO m, IsPrintDialog a, IsAsyncResult b) => a -> b -> m ()

-- | Finishes the <a>printDialogPrint</a> call and returns the results.
--   
--   If the call was successful, the content to be printed should be
--   written to the returned output stream. Otherwise, <tt>NULL</tt> is
--   returned.
--   
--   The overall results of the print operation will be returned in the
--   <a>outputStreamClose</a> call, so if you are interested in the
--   results, you need to explicitly close the output stream (it will be
--   closed automatically if you just unref it). Be aware that the close
--   call may not be instant as it operation will for the printer to finish
--   printing.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.14</i>
printDialogPrintFinish :: (HasCallStack, MonadIO m, IsPrintDialog a, IsAsyncResult b) => a -> b -> m OutputStream

-- | Sets the label that will be shown on the accept button of the print
--   dialog shown for <a>printDialogSetup</a>.
--   
--   <i>Since: 4.14</i>
printDialogSetAcceptLabel :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> Text -> m ()

-- | Sets whether the print dialog blocks interaction with the parent
--   window while it is presented.
--   
--   <i>Since: 4.14</i>
printDialogSetModal :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> Bool -> m ()

-- | Set the page setup for the print dialog.
--   
--   <i>Since: 4.14</i>
printDialogSetPageSetup :: (HasCallStack, MonadIO m, IsPrintDialog a, IsPageSetup b) => a -> b -> m ()

-- | Sets the print settings for the print dialog.
--   
--   <i>Since: 4.14</i>
printDialogSetPrintSettings :: (HasCallStack, MonadIO m, IsPrintDialog a, IsPrintSettings b) => a -> b -> m ()

-- | Sets the title that will be shown on the print dialog.
--   
--   <i>Since: 4.14</i>
printDialogSetTitle :: (HasCallStack, MonadIO m, IsPrintDialog a) => a -> Text -> m ()

-- | This function presents a print dialog to let the user select a
--   printer, and set up print settings and page setup.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is
--   dismissed. The obtained <a>PrintSetup</a> can then be passed to
--   <a>printDialogPrint</a> or <a>printDialogPrintFile</a>.
--   
--   One possible use for this method is to have the user select a printer,
--   then show a page setup UI in the application (e.g. to arrange images
--   on a page), then call <a>printDialogPrint</a> on <i><tt>self</tt></i>
--   to do the printing without further user interaction.
--   
--   <i>Since: 4.14</i>
printDialogSetup :: (HasCallStack, MonadIO m, IsPrintDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>printDialogSetup</a> call.
--   
--   If the call was successful, it returns a <a>PrintSetup</a> which
--   contains the print settings and page setup information that will be
--   used to print.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.14</i>
printDialogSetupFinish :: (HasCallStack, MonadIO m, IsPrintDialog a, IsAsyncResult b) => a -> b -> m PrintSetup

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accept-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPrintDialogAcceptLabel :: (IsPrintDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printDialog #acceptLabel
--   </pre>
getPrintDialogAcceptLabel :: (MonadIO m, IsPrintDialog o) => o -> m Text

-- | Set the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printDialog [ #acceptLabel <a>:=</a> value ]
--   </pre>
setPrintDialogAcceptLabel :: (MonadIO m, IsPrintDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintDialogModal :: (IsPrintDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printDialog #modal
--   </pre>
getPrintDialogModal :: (MonadIO m, IsPrintDialog o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printDialog [ #modal <a>:=</a> value ]
--   </pre>
setPrintDialogModal :: (MonadIO m, IsPrintDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-setup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPrintDialogPageSetup :: (IsPrintDialog o, MonadIO m, IsPageSetup a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printDialog #pageSetup
--   </pre>
getPrintDialogPageSetup :: (MonadIO m, IsPrintDialog o) => o -> m (Maybe PageSetup)

-- | Set the value of the “<tt>page-setup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printDialog [ #pageSetup <a>:=</a> value ]
--   </pre>
setPrintDialogPageSetup :: (MonadIO m, IsPrintDialog o, IsPageSetup a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>print-settings</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPrintDialogPrintSettings :: (IsPrintDialog o, MonadIO m, IsPrintSettings a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printDialog #printSettings
--   </pre>
getPrintDialogPrintSettings :: (MonadIO m, IsPrintDialog o) => o -> m (Maybe PrintSettings)

-- | Set the value of the “<tt>print-settings</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printDialog [ #printSettings <a>:=</a> value ]
--   </pre>
setPrintDialogPrintSettings :: (MonadIO m, IsPrintDialog o, IsPrintSettings a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPrintDialogTitle :: (IsPrintDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> printDialog #title
--   </pre>
getPrintDialogTitle :: (MonadIO m, IsPrintDialog o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> printDialog [ #title <a>:=</a> value ]
--   </pre>
setPrintDialogTitle :: (MonadIO m, IsPrintDialog o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PrintDialog.PrintDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PrintDialog.PrintDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PrintDialog.PrintDialog
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PrintDialog.PrintDialog)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PrintDialog.PrintDialog o) => GI.Gtk.Objects.PrintDialog.IsPrintDialog o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PrintDialog.PrintDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PrintDialog.PrintDialog


-- | Presents a horizontal bar of items that pop up menus when clicked.
--   
--   &lt;picture&gt; &lt;source srcset="menubar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPopoverMenuBar" src="menubar.png"&gt; &lt;/picture&gt;
--   
--   The only way to create instances of <tt>GtkPopoverMenuBar</tt> is from
--   a <tt>GMenuModel</tt>.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   menubar
--   ├── item[.active]
--   ┊   ╰── popover
--   ╰── item
--       ╰── popover
--   </pre>
--   
--   <tt>GtkPopoverMenuBar</tt> has a single CSS node with name menubar,
--   below which each item has its CSS node, and below that the
--   corresponding popover.
--   
--   The item whose popover is currently open gets the .active style class.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkPopoverMenuBar</tt> uses the <a>AccessibleRoleMenuBar</a> role,
--   the menu items use the <a>AccessibleRoleMenuItem</a> role and the
--   menus use the <a>AccessibleRoleMenu</a> role.
module GI.Gtk.Objects.PopoverMenuBar

-- | Memory-managed wrapper type.
newtype PopoverMenuBar
PopoverMenuBar :: ManagedPtr PopoverMenuBar -> PopoverMenuBar

-- | Type class for types which can be safely cast to
--   <a>PopoverMenuBar</a>, for instance with <a>toPopoverMenuBar</a>.
class (GObject o, IsDescendantOf PopoverMenuBar o) => IsPopoverMenuBar o

-- | Cast to <a>PopoverMenuBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPopoverMenuBar :: (MonadIO m, IsPopoverMenuBar o) => o -> m PopoverMenuBar

-- | Adds a custom widget to a generated menubar.
--   
--   For this to work, the menu model of <i><tt>bar</tt></i> must have an
--   item with a <tt>custom</tt> attribute that matches <i><tt>id</tt></i>.
popoverMenuBarAddChild :: (HasCallStack, MonadIO m, IsPopoverMenuBar a, IsWidget b) => a -> b -> Text -> m Bool

-- | Returns the model from which the contents of <i><tt>bar</tt></i> are
--   taken.
popoverMenuBarGetMenuModel :: (HasCallStack, MonadIO m, IsPopoverMenuBar a) => a -> m (Maybe MenuModel)

-- | Creates a <tt>GtkPopoverMenuBar</tt> from a <tt>GMenuModel</tt>.
popoverMenuBarNewFromModel :: (HasCallStack, MonadIO m, IsMenuModel a) => Maybe a -> m PopoverMenuBar

-- | Removes a widget that has previously been added with
--   <a>popoverMenuBarAddChild</a>.
popoverMenuBarRemoveChild :: (HasCallStack, MonadIO m, IsPopoverMenuBar a, IsWidget b) => a -> b -> m Bool

-- | Sets a menu model from which <i><tt>bar</tt></i> should take its
--   contents.
popoverMenuBarSetMenuModel :: (HasCallStack, MonadIO m, IsPopoverMenuBar a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>menu-model</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuModel
--   </pre>
clearPopoverMenuBarMenuModel :: (MonadIO m, IsPopoverMenuBar o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-model</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPopoverMenuBarMenuModel :: (IsPopoverMenuBar o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverMenuBar #menuModel
--   </pre>
getPopoverMenuBarMenuModel :: (MonadIO m, IsPopoverMenuBar o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverMenuBar [ #menuModel <a>:=</a> value ]
--   </pre>
setPopoverMenuBarMenuModel :: (MonadIO m, IsPopoverMenuBar o, IsMenuModel a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar o) => GI.Gtk.Objects.PopoverMenuBar.IsPopoverMenuBar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar


-- | A subclass of <tt>GtkPopover</tt> that implements menu behavior.
--   
--   &lt;picture&gt; &lt;source srcset="menu-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPopoverMenu" src="menu.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkPopoverMenu</tt> treats its children like menus and allows
--   switching between them. It can open submenus as traditional, nested
--   submenus, or in a more touch-friendly sliding fashion. The property
--   <a>PopoverMenu:flags</a> controls this appearance.
--   
--   <tt>GtkPopoverMenu</tt> is meant to be used primarily with menu
--   models, using <a>popoverMenuNewFromModel</a>. If you need to put other
--   widgets such as a <tt>GtkSpinButton</tt> or a <tt>GtkSwitch</tt> into
--   a popover, you can use <a>popoverMenuAddChild</a>.
--   
--   For more dialog-like behavior, use a plain <tt>GtkPopover</tt>.
--   
--   <h2>Menu models</h2>
--   
--   The XML format understood by <tt>GtkBuilder</tt> for
--   <tt>GMenuModel</tt> consists of a toplevel <tt>&lt;menu&gt;</tt>
--   element, which contains one or more <tt>&lt;item&gt;</tt> elements.
--   Each <tt>&lt;item&gt;</tt> element contains <tt>&lt;attribute&gt;</tt>
--   and <tt>&lt;link&gt;</tt> elements with a mandatory name attribute.
--   <tt>&lt;link&gt;</tt> elements have the same content model as
--   <tt>&lt;menu&gt;</tt>. Instead of <tt>&lt;link name="submenu"&gt;</tt>
--   or <tt>&lt;link name="section"&gt;</tt>, you can use
--   <tt>&lt;submenu&gt;</tt> or <tt>&lt;section&gt;</tt> elements.
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;menu id='app-menu'&gt;
--     &lt;section&gt;
--       &lt;item&gt;
--         &lt;attribute name='label' translatable='yes'&gt;_New Window&lt;/attribute&gt;
--         &lt;attribute name='action'&gt;app.new&lt;/attribute&gt;
--       &lt;/item&gt;
--       &lt;item&gt;
--         &lt;attribute name='label' translatable='yes'&gt;_About Sunny&lt;/attribute&gt;
--         &lt;attribute name='action'&gt;app.about&lt;/attribute&gt;
--       &lt;/item&gt;
--       &lt;item&gt;
--         &lt;attribute name='label' translatable='yes'&gt;_Quit&lt;/attribute&gt;
--         &lt;attribute name='action'&gt;app.quit&lt;/attribute&gt;
--       &lt;/item&gt;
--     &lt;/section&gt;
--   &lt;/menu&gt;
--   </pre>
--   
--   Attribute values can be translated using gettext, like other
--   <tt>GtkBuilder</tt> content. <tt>&lt;attribute&gt;</tt> elements can
--   be marked for translation with a <tt>translatable="yes"</tt>
--   attribute. It is also possible to specify message context and
--   translator comments, using the context and comments attributes. To
--   make use of this, the <tt>GtkBuilder</tt> must have been given the
--   gettext domain to use.
--   
--   The following attributes are used when constructing menu items:
--   
--   <ul>
--   <li>"label": a user-visible string to display</li>
--   <li>"use-markup": whether the text in the menu item includes <a>Pango
--   markup</a></li>
--   <li>"action": the prefixed name of the action to trigger</li>
--   <li>"target": the parameter to use when activating the action</li>
--   <li>"icon" and "verb-icon": names of icons that may be displayed</li>
--   <li>"submenu-action": name of an action that may be used to track
--   whether a submenu is open</li>
--   <li>"hidden-when": a string used to determine when the item will be
--   hidden. Possible values include "action-disabled", "action-missing",
--   "macos-menubar". This is mainly useful for exported menus, see
--   <a>applicationSetMenubar</a>.</li>
--   <li>"custom": a string used to match against the ID of a custom child
--   added with <a>popoverMenuAddChild</a>, <a>popoverMenuBarAddChild</a>,
--   or in the ui file with <tt>&lt;child type="ID"&gt;</tt>.</li>
--   </ul>
--   
--   The following attributes are used when constructing sections:
--   
--   <ul>
--   <li>"label": a user-visible string to use as section heading</li>
--   <li>"display-hint": a string used to determine special formatting for
--   the section. Possible values include "horizontal-buttons",
--   "circular-buttons" and "inline-buttons". They all indicate that
--   section should be displayed as a horizontal row of buttons.</li>
--   <li>"text-direction": a string used to determine the
--   <tt>GtkTextDirection</tt> to use when "display-hint" is set to
--   "horizontal-buttons". Possible values include "rtl", "ltr", and
--   "none".</li>
--   </ul>
--   
--   The following attributes are used when constructing submenus:
--   
--   <ul>
--   <li>"label": a user-visible string to display</li>
--   <li>"icon": icon name to display</li>
--   <li>"gtk-macos-special": (macOS only, ignored by others) Add special
--   meaning to a menu in the macOS menu bar. See <a>Using GTK on Apple
--   macOS</a>.</li>
--   </ul>
--   
--   Menu items will also show accelerators, which are usually associated
--   with actions via <a>applicationSetAccelsForAction</a>,
--   [method<i><tt>widgetClass</tt></i>.add_binding_action] or
--   <a>shortcutControllerAddShortcut</a>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkPopoverMenu</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Space&lt;/kbd&gt; activates the default widget.</li>
--   </ul>
--   
--   <h1>CSS Nodes</h1>
--   
--   <tt>GtkPopoverMenu</tt> is just a subclass of <tt>GtkPopover</tt> that
--   adds custom content to it, therefore it has the same CSS nodes. It is
--   one of the cases that add a <tt>.menu</tt> style class to the main
--   <tt>popover</tt> node.
--   
--   Menu items have nodes with name <tt>button</tt> and class
--   <tt>.model</tt>. If a section display-hint is set, the section gets a
--   node <tt>box</tt> with class <tt>horizontal</tt> plus a class with the
--   same text as the display hint. Note that said box may not be the
--   direct ancestor of the item <tt>button</tt>s. Thus, for example, to
--   style items in an <tt>inline-buttons</tt> section, select
--   <tt>.inline-buttons button.model</tt>. Other things that may be of
--   interest to style in menus include <tt>label</tt> nodes.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkPopoverMenu</tt> uses the <a>AccessibleRoleMenu</a> role, and
--   its items use the <a>AccessibleRoleMenuItem</a>,
--   <a>AccessibleRoleCheckbox</a> or <a>AccessibleRoleMenuItemRadio</a>
--   roles, depending on the action they are connected to.
module GI.Gtk.Objects.PopoverMenu

-- | Memory-managed wrapper type.
newtype PopoverMenu
PopoverMenu :: ManagedPtr PopoverMenu -> PopoverMenu

-- | Type class for types which can be safely cast to <a>PopoverMenu</a>,
--   for instance with <a>toPopoverMenu</a>.
class (GObject o, IsDescendantOf PopoverMenu o) => IsPopoverMenu o

-- | Cast to <a>PopoverMenu</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPopoverMenu :: (MonadIO m, IsPopoverMenu o) => o -> m PopoverMenu

-- | Adds a custom widget to a generated menu.
--   
--   For this to work, the menu model of <i><tt>popover</tt></i> must have
--   an item with a <tt>custom</tt> attribute that matches
--   <i><tt>id</tt></i>.
popoverMenuAddChild :: (HasCallStack, MonadIO m, IsPopoverMenu a, IsWidget b) => a -> b -> Text -> m Bool

-- | Returns the flags that <i><tt>popover</tt></i> uses to create/display
--   a menu from its model.
--   
--   <i>Since: 4.14</i>
popoverMenuGetFlags :: (HasCallStack, MonadIO m, IsPopoverMenu a) => a -> m [PopoverMenuFlags]

-- | Returns the menu model used to populate the popover.
popoverMenuGetMenuModel :: (HasCallStack, MonadIO m, IsPopoverMenu a) => a -> m (Maybe MenuModel)

-- | Creates a <tt>GtkPopoverMenu</tt> and populates it according to
--   <i><tt>model</tt></i>.
--   
--   The created buttons are connected to actions found in the
--   <tt>GtkApplicationWindow</tt> to which the popover belongs - typically
--   by means of being attached to a widget that is contained within the
--   <tt>GtkApplicationWindow</tt>s widget hierarchy.
--   
--   Actions can also be added using <a>widgetInsertActionGroup</a> on the
--   menus attach widget or on any of its parent widgets.
--   
--   This function creates menus with sliding submenus. See
--   <a>popoverMenuNewFromModelFull</a> for a way to control this.
popoverMenuNewFromModel :: (HasCallStack, MonadIO m, IsMenuModel a) => Maybe a -> m PopoverMenu

-- | Creates a <tt>GtkPopoverMenu</tt> and populates it according to
--   <i><tt>model</tt></i>.
--   
--   The created buttons are connected to actions found in the action
--   groups that are accessible from the parent widget. This includes the
--   <tt>GtkApplicationWindow</tt> to which the popover belongs. Actions
--   can also be added using <a>widgetInsertActionGroup</a> on the parent
--   widget or on any of its parent widgets.
popoverMenuNewFromModelFull :: (HasCallStack, MonadIO m, IsMenuModel a) => a -> [PopoverMenuFlags] -> m PopoverMenu

-- | Removes a widget that has previously been added with
--   <a>popoverMenuAddChild</a>
popoverMenuRemoveChild :: (HasCallStack, MonadIO m, IsPopoverMenu a, IsWidget b) => a -> b -> m Bool

-- | Sets the flags that <i><tt>popover</tt></i> uses to create/display a
--   menu from its model.
--   
--   If a model is set and the flags change, contents are rebuilt, so if
--   setting properties individually, set flags before model to avoid a
--   redundant rebuild.
--   
--   <i>Since: 4.14</i>
popoverMenuSetFlags :: (HasCallStack, MonadIO m, IsPopoverMenu a) => a -> [PopoverMenuFlags] -> m ()

-- | Sets a new menu model on <i><tt>popover</tt></i>.
--   
--   The existing contents of <i><tt>popover</tt></i> are removed, and the
--   <i><tt>popover</tt></i> is populated with new contents according to
--   <i><tt>model</tt></i>.
popoverMenuSetMenuModel :: (HasCallStack, MonadIO m, IsPopoverMenu a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPopoverMenuFlags :: (IsPopoverMenu o, MonadIO m) => [PopoverMenuFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverMenu #flags
--   </pre>
getPopoverMenuFlags :: (MonadIO m, IsPopoverMenu o) => o -> m [PopoverMenuFlags]

-- | Set the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverMenu [ #flags <a>:=</a> value ]
--   </pre>
setPopoverMenuFlags :: (MonadIO m, IsPopoverMenu o) => o -> [PopoverMenuFlags] -> m ()

-- | Set the value of the “<tt>menu-model</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuModel
--   </pre>
clearPopoverMenuMenuModel :: (MonadIO m, IsPopoverMenu o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-model</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPopoverMenuMenuModel :: (IsPopoverMenu o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverMenu #menuModel
--   </pre>
getPopoverMenuMenuModel :: (MonadIO m, IsPopoverMenu o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverMenu [ #menuModel <a>:=</a> value ]
--   </pre>
setPopoverMenuMenuModel :: (MonadIO m, IsPopoverMenu o, IsMenuModel a) => o -> a -> m ()

-- | Set the value of the “<tt>visible-submenu</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #visibleSubmenu
--   </pre>
clearPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible-submenu</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPopoverMenuVisibleSubmenu :: (IsPopoverMenu o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible-submenu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverMenu #visibleSubmenu
--   </pre>
getPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>visible-submenu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverMenu [ #visibleSubmenu <a>:=</a> value ]
--   </pre>
setPopoverMenuVisibleSubmenu :: (MonadIO m, IsPopoverMenu o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PopoverMenu.PopoverMenu
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PopoverMenu.PopoverMenu
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PopoverMenu.PopoverMenu
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PopoverMenu.PopoverMenu)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PopoverMenu.PopoverMenu o) => GI.Gtk.Objects.PopoverMenu.IsPopoverMenu o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PopoverMenu.PopoverMenu
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PopoverMenu.PopoverMenu


-- | A single child container with a popover.
--   
--   You should use <tt>GtkPopoverBin</tt> whenever you need to present a
--   <a>Popover</a> to the user.
--   
--   <h2>Actions</h2>
--   
--   <tt>GtkPopoverBin</tt> defines the <tt>menu.popup</tt> action, which
--   can be activated to present the popover to the user.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkPopoverBin</tt> has a single CSS node with the name
--   <tt>popoverbin</tt>.
--   
--   <i>Since: 4.22</i>
module GI.Gtk.Objects.PopoverBin

-- | Memory-managed wrapper type.
newtype PopoverBin
PopoverBin :: ManagedPtr PopoverBin -> PopoverBin

-- | Type class for types which can be safely cast to <a>PopoverBin</a>,
--   for instance with <a>toPopoverBin</a>.
class (GObject o, IsDescendantOf PopoverBin o) => IsPopoverBin o

-- | Cast to <a>PopoverBin</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPopoverBin :: (MonadIO m, IsPopoverBin o) => o -> m PopoverBin

-- | Retrieves the child widget of the popover bin.
--   
--   <i>Since: 4.22</i>
popoverBinGetChild :: (HasCallStack, MonadIO m, IsPopoverBin a) => a -> m (Maybe Widget)

-- | <i>No description available in the introspection data.</i>
popoverBinGetHandleInput :: (HasCallStack, MonadIO m, IsPopoverBin a) => a -> m Bool

-- | Retrieves the menu model set using <a>popoverBinSetMenuModel</a>.
--   
--   <i>Since: 4.22</i>
popoverBinGetMenuModel :: (HasCallStack, MonadIO m, IsPopoverBin a) => a -> m (Maybe MenuModel)

-- | Retrieves the <tt>GtkPopover</tt> set using
--   <a>popoverBinSetPopover</a>.
--   
--   <i>Since: 4.22</i>
popoverBinGetPopover :: (HasCallStack, MonadIO m, IsPopoverBin a) => a -> m (Maybe Popover)

-- | Creates a new popover bin widget.
--   
--   <i>Since: 4.22</i>
popoverBinNew :: (HasCallStack, MonadIO m) => m PopoverBin

-- | Hides the popover from the user.
--   
--   See: <a>popoverBinPopup</a>
--   
--   <i>Since: 4.22</i>
popoverBinPopdown :: (HasCallStack, MonadIO m, IsPopoverBin a) => a -> m ()

-- | Presents the popover to the user.
--   
--   Use <a>popoverBinSetPopover</a> or <a>popoverBinSetMenuModel</a> to
--   define the popover.
--   
--   See: <a>popoverBinPopdown</a>
--   
--   <i>Since: 4.22</i>
popoverBinPopup :: (HasCallStack, MonadIO m, IsPopoverBin a) => a -> m ()

-- | Sets the child of the popover bin.
--   
--   <i>Since: 4.22</i>
popoverBinSetChild :: (HasCallStack, MonadIO m, IsPopoverBin a, IsWidget b) => a -> Maybe b -> m ()

-- | Enables or disables input handling.
--   
--   If enabled, the popover bin will pop up the popover on right-click or
--   long press, as expected for a context menu.
--   
--   <i>Since: 4.22</i>
popoverBinSetHandleInput :: (HasCallStack, MonadIO m, IsPopoverBin a) => a -> Bool -> m ()

-- | Sets the menu model used to create the popover that will be presented
--   when calling <a>popoverBinPopup</a>.
--   
--   If <i><tt>model</tt></i> is <tt>NULL</tt>, the popover will be unset.
--   
--   A <a>Popover</a> will be created from the menu model with
--   <a>popoverMenuNewFromModel</a>. Actions will be connected as
--   documented for this function.
--   
--   If <a>PopoverBin:popover</a> is already set, it will be dissociated
--   from the popover bin, and the property is set to <tt>NULL</tt>.
--   
--   See: <a>popoverBinSetPopover</a>
--   
--   <i>Since: 4.22</i>
popoverBinSetMenuModel :: (HasCallStack, MonadIO m, IsPopoverBin a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkPopover</tt> that will be presented when calling
--   <a>popoverBinPopup</a>.
--   
--   If <i><tt>popover</tt></i> is <tt>NULL</tt>, the popover will be
--   unset.
--   
--   If <a>PopoverBin:menuModel</a> is set before calling this function,
--   then the menu model property will be unset.
--   
--   See: <a>popoverBinSetMenuModel</a>
--   
--   <i>Since: 4.22</i>
popoverBinSetPopover :: (HasCallStack, MonadIO m, IsPopoverBin a, IsPopover b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearPopoverBinChild :: (MonadIO m, IsPopoverBin o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPopoverBinChild :: (IsPopoverBin o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverBin #child
--   </pre>
getPopoverBinChild :: (MonadIO m, IsPopoverBin o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverBin [ #child <a>:=</a> value ]
--   </pre>
setPopoverBinChild :: (MonadIO m, IsPopoverBin o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>handle-input</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPopoverBinHandleInput :: (IsPopoverBin o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>handle-input</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverBin #handleInput
--   </pre>
getPopoverBinHandleInput :: (MonadIO m, IsPopoverBin o) => o -> m Bool

-- | Set the value of the “<tt>handle-input</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverBin [ #handleInput <a>:=</a> value ]
--   </pre>
setPopoverBinHandleInput :: (MonadIO m, IsPopoverBin o) => o -> Bool -> m ()

-- | Set the value of the “<tt>menu-model</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuModel
--   </pre>
clearPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-model</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPopoverBinMenuModel :: (IsPopoverBin o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverBin #menuModel
--   </pre>
getPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverBin [ #menuModel <a>:=</a> value ]
--   </pre>
setPopoverBinMenuModel :: (MonadIO m, IsPopoverBin o, IsMenuModel a) => o -> a -> m ()

-- | Set the value of the “<tt>popover</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #popover
--   </pre>
clearPopoverBinPopover :: (MonadIO m, IsPopoverBin o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popover</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPopoverBinPopover :: (IsPopoverBin o, MonadIO m, IsPopover a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popoverBin #popover
--   </pre>
getPopoverBinPopover :: (MonadIO m, IsPopoverBin o) => o -> m (Maybe Popover)

-- | Set the value of the “<tt>popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popoverBin [ #popover <a>:=</a> value ]
--   </pre>
setPopoverBinPopover :: (MonadIO m, IsPopoverBin o, IsPopover a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PopoverBin.PopoverBin
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PopoverBin.PopoverBin
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PopoverBin.PopoverBin
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PopoverBin.PopoverBin)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PopoverBin.PopoverBin o) => GI.Gtk.Objects.PopoverBin.IsPopoverBin o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PopoverBin.PopoverBin
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PopoverBin.PopoverBin


-- | Presents a bubble-like popup.
--   
--   &lt;picture&gt; &lt;source srcset="popover-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPopover" src="popover.png"&gt; &lt;/picture&gt;
--   
--   It is primarily meant to provide context-dependent information or
--   options. Popovers are attached to a parent widget. The parent widget
--   must support popover children, as <a>MenuButton</a> and
--   <a>PopoverMenuBar</a> do. If you want to make a custom widget that has
--   an attached popover, you need to call <a>popoverPresent</a> in your
--   <a>Widget</a>.<tt><i>size_allocate</i></tt>() vfunc, in order to
--   update the positioning of the popover.
--   
--   The position of a popover relative to the widget it is attached to can
--   also be changed with <a>popoverSetPosition</a>. By default, it points
--   to the whole widget area, but it can be made to point to a specific
--   area using <a>popoverSetPointingTo</a>.
--   
--   By default, <tt>GtkPopover</tt> performs a grab, in order to ensure
--   input events get redirected to it while it is shown, and also so the
--   popover is dismissed in the expected situations (clicks outside the
--   popover, or the Escape key being pressed). If no such modal behavior
--   is desired on a popover, <a>popoverSetAutohide</a> may be called on it
--   to tweak its behavior.
--   
--   <h2>GtkPopover as menu replacement</h2>
--   
--   <tt>GtkPopover</tt> is often used to replace menus. The best way to do
--   this is to use the <a>PopoverMenu</a> subclass which supports being
--   populated from a <tt>GMenuModel</tt> with
--   <a>popoverMenuNewFromModel</a>.
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;section&gt;
--     &lt;attribute name="display-hint"&gt;horizontal-buttons&lt;/attribute&gt;
--     &lt;item&gt;
--       &lt;attribute name="label"&gt;Cut&lt;/attribute&gt;
--       &lt;attribute name="action"&gt;app.cut&lt;/attribute&gt;
--       &lt;attribute name="verb-icon"&gt;edit-cut-symbolic&lt;/attribute&gt;
--     &lt;/item&gt;
--     &lt;item&gt;
--       &lt;attribute name="label"&gt;Copy&lt;/attribute&gt;
--       &lt;attribute name="action"&gt;app.copy&lt;/attribute&gt;
--       &lt;attribute name="verb-icon"&gt;edit-copy-symbolic&lt;/attribute&gt;
--     &lt;/item&gt;
--     &lt;item&gt;
--       &lt;attribute name="label"&gt;Paste&lt;/attribute&gt;
--       &lt;attribute name="action"&gt;app.paste&lt;/attribute&gt;
--       &lt;attribute name="verb-icon"&gt;edit-paste-symbolic&lt;/attribute&gt;
--     &lt;/item&gt;
--   &lt;/section&gt;
--   </pre>
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkPopover</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Escape&lt;/kbd&gt; closes the popover.</li>
--   <li>&lt;kbd&gt;Alt&lt;/kbd&gt; makes the mnemonics visible.</li>
--   </ul>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>Popover::activateDefault</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   popover.background[.menu]
--   ├── arrow
--   ╰── contents
--       ╰── &lt;child&gt;
--   </pre>
--   
--   <tt>GtkPopover</tt> has a main node with name <tt>popover</tt>, an
--   arrow with name <tt>arrow</tt>, and another node for the content named
--   <tt>contents</tt>. The <tt>popover</tt> node always gets the
--   <tt>.background</tt> style class. It also gets the <tt>.menu</tt>
--   style class if the popover is menu-like, e.g. is a <a>PopoverMenu</a>.
--   
--   Particular uses of <tt>GtkPopover</tt>, such as touch selection popups
--   or magnifiers in <tt>GtkEntry</tt> or <tt>GtkTextView</tt> get style
--   classes like <tt>.touch-selection</tt> or <tt>.magnifier</tt> to
--   differentiate from plain popovers.
--   
--   When styling a popover directly, the <tt>popover</tt> node should
--   usually not have any background. The visible part of the popover can
--   have a shadow. To specify it in CSS, set the box-shadow of the
--   <tt>contents</tt> node.
--   
--   Note that, in order to accomplish appropriate arrow visuals,
--   <tt>GtkPopover</tt> uses custom drawing for the <tt>arrow</tt> node.
--   This makes it possible for the arrow to change its shape dynamically,
--   but it also limits the possibilities of styling it using CSS. In
--   particular, the <tt>arrow</tt> gets drawn over the <tt>content</tt>
--   node's border and shadow, so they look like one shape, which means
--   that the border width of the <tt>content</tt> node and the
--   <tt>arrow</tt> node should be the same. The arrow also does not
--   support any border shape other than solid, no border-radius, only one
--   border width (border-bottom-width is used) and no box-shadow.
module GI.Gtk.Objects.Popover

-- | Memory-managed wrapper type.
newtype Popover
Popover :: ManagedPtr Popover -> Popover

-- | Type class for types which can be safely cast to <a>Popover</a>, for
--   instance with <a>toPopover</a>.
class (GObject o, IsDescendantOf Popover o) => IsPopover o

-- | Cast to <a>Popover</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toPopover :: (MonadIO m, IsPopover o) => o -> m Popover

-- | Returns whether the popover is modal.
--   
--   See <a>popoverSetAutohide</a> for the implications of this.
popoverGetAutohide :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | Returns whether the popover will close after a modal child is closed.
popoverGetCascadePopdown :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | Gets the child widget of <i><tt>popover</tt></i>.
popoverGetChild :: (HasCallStack, MonadIO m, IsPopover a) => a -> m (Maybe Widget)

-- | Gets whether this popover is showing an arrow pointing at the widget
--   that it is relative to.
popoverGetHasArrow :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | Gets whether mnemonics are visible.
popoverGetMnemonicsVisible :: (HasCallStack, MonadIO m, IsPopover a) => a -> m Bool

-- | Gets the offset previous set with <a>popoverSetOffset</a>.
popoverGetOffset :: (HasCallStack, MonadIO m, IsPopover a) => a -> m (Int32, Int32)

-- | Gets the rectangle that the popover points to.
--   
--   If a rectangle to point to has been set, this function will return
--   <a>True</a> and fill in <i><tt>rect</tt></i> with such rectangle,
--   otherwise it will return <a>False</a> and fill in <i><tt>rect</tt></i>
--   with the parent widget coordinates.
popoverGetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> m (Bool, Rectangle)

-- | Returns the preferred position of <i><tt>popover</tt></i>.
popoverGetPosition :: (HasCallStack, MonadIO m, IsPopover a) => a -> m PositionType

-- | Creates a new <tt>GtkPopover</tt>.
popoverNew :: (HasCallStack, MonadIO m) => m Popover

-- | Pops <i><tt>popover</tt></i> down.
--   
--   This may have the side-effect of closing a parent popover as well. See
--   <a>Popover:cascadePopdown</a>.
popoverPopdown :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ()

-- | Pops <i><tt>popover</tt></i> up.
popoverPopup :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ()

-- | Allocate a size for the <tt>GtkPopover</tt>.
--   
--   This function needs to be called in size-allocate by widgets who have
--   a <tt>GtkPopover</tt> as child. When using a layout manager, this is
--   happening automatically.
--   
--   To make a popover appear on screen, use <a>popoverPopup</a>.
popoverPresent :: (HasCallStack, MonadIO m, IsPopover a) => a -> m ()

-- | Sets whether <i><tt>popover</tt></i> is modal.
--   
--   A modal popover will grab the keyboard focus on it when being
--   displayed. Focus will wrap around within the popover. Clicking outside
--   the popover area or pressing Esc will dismiss the popover.
--   
--   Called this function on an already showing popup with a new autohide
--   value different from the current one, will cause the popup to be
--   hidden.
popoverSetAutohide :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | If <i><tt>cascadePopdown</tt></i> is <a>True</a>, the popover will be
--   closed when a child modal popover is closed.
--   
--   If <a>False</a>, <i><tt>popover</tt></i> will stay visible.
popoverSetCascadePopdown :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | Sets the child widget of <i><tt>popover</tt></i>.
popoverSetChild :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the default widget of a <tt>GtkPopover</tt>.
--   
--   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 <tt>GtkPopover</tt>.
popoverSetDefaultWidget :: (HasCallStack, MonadIO m, IsPopover a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether this popover should draw an arrow pointing at the widget
--   it is relative to.
popoverSetHasArrow :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | Sets whether mnemonics should be visible.
popoverSetMnemonicsVisible :: (HasCallStack, MonadIO m, IsPopover a) => a -> Bool -> m ()

-- | Sets the offset to use when calculating the position of the popover.
--   
--   These values are used when preparing the <a>PopupLayout</a> for
--   positioning the popover.
popoverSetOffset :: (HasCallStack, MonadIO m, IsPopover a) => a -> Int32 -> Int32 -> m ()

-- | Sets the rectangle that <i><tt>popover</tt></i> points to.
--   
--   This is in the coordinate space of the <i><tt>popover</tt></i> parent.
popoverSetPointingTo :: (HasCallStack, MonadIO m, IsPopover a) => a -> Maybe Rectangle -> m ()

-- | Sets the preferred position for <i><tt>popover</tt></i> to appear.
--   
--   If the <i><tt>popover</tt></i> is currently visible, it will be
--   immediately updated.
--   
--   This preference will be respected where possible, although on lack of
--   space (eg. if close to the window edges), the <tt>GtkPopover</tt> may
--   choose to appear on the opposite side.
popoverSetPosition :: (HasCallStack, MonadIO m, IsPopover a) => a -> PositionType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>autohide</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPopoverAutohide :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>autohide</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #autohide
--   </pre>
getPopoverAutohide :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “<tt>autohide</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #autohide <a>:=</a> value ]
--   </pre>
setPopoverAutohide :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cascade-popdown</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPopoverCascadePopdown :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>cascade-popdown</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #cascadePopdown
--   </pre>
getPopoverCascadePopdown :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “<tt>cascade-popdown</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #cascadePopdown <a>:=</a> value ]
--   </pre>
setPopoverCascadePopdown :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearPopoverChild :: (MonadIO m, IsPopover o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPopoverChild :: (IsPopover o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #child
--   </pre>
getPopoverChild :: (MonadIO m, IsPopover o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #child <a>:=</a> value ]
--   </pre>
setPopoverChild :: (MonadIO m, IsPopover o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>default-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #defaultWidget
--   </pre>
clearPopoverDefaultWidget :: (MonadIO m, IsPopover o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-widget</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPopoverDefaultWidget :: (IsPopover o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #defaultWidget
--   </pre>
getPopoverDefaultWidget :: (MonadIO m, IsPopover o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>default-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #defaultWidget <a>:=</a> value ]
--   </pre>
setPopoverDefaultWidget :: (MonadIO m, IsPopover o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-arrow</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPopoverHasArrow :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #hasArrow
--   </pre>
getPopoverHasArrow :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “<tt>has-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #hasArrow <a>:=</a> value ]
--   </pre>
setPopoverHasArrow :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mnemonics-visible</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPopoverMnemonicsVisible :: (IsPopover o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>mnemonics-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #mnemonicsVisible
--   </pre>
getPopoverMnemonicsVisible :: (MonadIO m, IsPopover o) => o -> m Bool

-- | Set the value of the “<tt>mnemonics-visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #mnemonicsVisible <a>:=</a> value ]
--   </pre>
setPopoverMnemonicsVisible :: (MonadIO m, IsPopover o) => o -> Bool -> m ()

-- | Set the value of the “<tt>pointing-to</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #pointingTo
--   </pre>
clearPopoverPointingTo :: (MonadIO m, IsPopover o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pointing-to</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPopoverPointingTo :: (IsPopover o, MonadIO m) => Rectangle -> m (GValueConstruct o)

-- | Get the value of the “<tt>pointing-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #pointingTo
--   </pre>
getPopoverPointingTo :: (MonadIO m, IsPopover o) => o -> m (Maybe Rectangle)

-- | Set the value of the “<tt>pointing-to</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #pointingTo <a>:=</a> value ]
--   </pre>
setPopoverPointingTo :: (MonadIO m, IsPopover o) => o -> Rectangle -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>position</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPopoverPosition :: (IsPopover o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> popover #position
--   </pre>
getPopoverPosition :: (MonadIO m, IsPopover o) => o -> m PositionType

-- | Set the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> popover [ #position <a>:=</a> value ]
--   </pre>
setPopoverPosition :: (MonadIO m, IsPopover o) => o -> PositionType -> m ()

-- | Emitted whend the user activates the default widget.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;Enter&lt;/kbd&gt;.
type PopoverActivateDefaultCallback = IO ()

-- | Connect a signal handler for the <a>activateDefault</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> popover #activateDefault callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPopoverActivateDefault :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverActivateDefaultCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateDefault</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> popover #activateDefault callback
--   </pre>
onPopoverActivateDefault :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverActivateDefaultCallback) -> m SignalHandlerId

-- | Emitted when the popover is closed.
type PopoverClosedCallback = IO ()

-- | Connect a signal handler for the <a>closed</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> popover #closed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPopoverClosed :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverClosedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>closed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> popover #closed callback
--   </pre>
onPopoverClosed :: (IsPopover a, MonadIO m) => a -> ((?self :: a) => PopoverClosedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Popover.Popover
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Popover.Popover
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Popover.Popover
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Popover.Popover)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Popover.Popover o) => GI.Gtk.Objects.Popover.IsPopover o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Popover.Popover
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Popover.Popover


-- | Displays a <tt>GdkPaintable</tt>.
--   
--   &lt;picture&gt; &lt;source srcset="picture-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPicture" src="picture.png"&gt; &lt;/picture&gt;
--   
--   Many convenience functions are provided to make pictures simple to
--   use. For example, if you want to load an image from a file, and then
--   display it, there’s a convenience function to do this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *widget = gtk_picture_new_for_filename ("myfile.png");
--   </pre>
--   
--   If the file isn’t loaded successfully, the picture will contain a
--   “broken image” icon similar to that used in many web browsers. If you
--   want to handle errors in loading the file yourself, for example by
--   displaying an error message, then load the image with and image
--   loading framework such as libglycin, then create the
--   <tt>GtkPicture</tt> with <a>pictureNewForPaintable</a>.
--   
--   Sometimes an application will want to avoid depending on external data
--   files, such as image files. See the documentation of
--   <tt>GResource</tt> for details. In this case,
--   <a>pictureNewForResource</a> and <a>pictureSetResource</a> should be
--   used.
--   
--   <tt>GtkPicture</tt> displays an image at its natural size. See
--   <a>Image</a> if you want to display a fixed-size image, such as an
--   icon.
--   
--   <h2>Sizing the paintable</h2>
--   
--   You can influence how the paintable is displayed inside the
--   <tt>GtkPicture</tt> by changing <a>Picture:contentFit</a>. See
--   <a>ContentFit</a> for details. <a>Picture:canShrink</a> can be unset
--   to make sure that paintables are never made smaller than their ideal
--   size - but be careful if you do not know the size of the paintable in
--   use (like when displaying user-loaded images). This can easily cause
--   the picture to grow larger than the screen. And <a>Widget:halign</a>
--   and <a>Widget:valign</a> can be used to make sure the paintable
--   doesn't fill all available space but is instead displayed at its
--   original size.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkPicture</tt> has a single CSS node with the name
--   <tt>picture</tt>.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkPicture</tt> uses the <a>AccessibleRoleImg</a> role.
module GI.Gtk.Objects.Picture

-- | Memory-managed wrapper type.
newtype Picture
Picture :: ManagedPtr Picture -> Picture

-- | Type class for types which can be safely cast to <a>Picture</a>, for
--   instance with <a>toPicture</a>.
class (GObject o, IsDescendantOf Picture o) => IsPicture o

-- | Cast to <a>Picture</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toPicture :: (MonadIO m, IsPicture o) => o -> m Picture

-- | Gets the alternative textual description of the picture.
--   
--   The returned string will be <a>Nothing</a> if the picture cannot be
--   described textually.
pictureGetAlternativeText :: (HasCallStack, MonadIO m, IsPicture a) => a -> m (Maybe Text)

-- | Returns whether the <tt>GtkPicture</tt> respects its contents size.
pictureGetCanShrink :: (HasCallStack, MonadIO m, IsPicture a) => a -> m Bool

-- | Returns the fit mode for the content of the <tt>GtkPicture</tt>.
--   
--   See <a>ContentFit</a> for details.
--   
--   <i>Since: 4.8</i>
pictureGetContentFit :: (HasCallStack, MonadIO m, IsPicture a) => a -> m ContentFit

-- | Gets the <tt>GFile</tt> currently displayed if <i><tt>self</tt></i> is
--   displaying a file.
--   
--   If <i><tt>self</tt></i> is not displaying a file, for example when
--   <a>pictureSetPaintable</a> was used, then <a>Nothing</a> is returned.
pictureGetFile :: (HasCallStack, MonadIO m, IsPicture a) => a -> m (Maybe File)

-- | Returns whether the contents are isolated.
--   
--   <i>Since: 4.22</i>
pictureGetIsolateContents :: (HasCallStack, MonadIO m, IsPicture a) => a -> m Bool

-- | Returns whether the <tt>GtkPicture</tt> preserves its contents aspect
--   ratio.

-- | <i>Deprecated: (Since version 4.8)Use <a>pictureGetContentFit</a>
--   instead. This willnow return <tt>FALSE</tt> only if
--   <a>Picture:contentFit</a> is<tt>GTK_CONTENT_FIT_FILL</tt>. Returns
--   <tt>TRUE</tt> otherwise.</i>
pictureGetKeepAspectRatio :: (HasCallStack, MonadIO m, IsPicture a) => a -> m Bool

-- | Gets the <tt>GdkPaintable</tt> being displayed by the
--   <tt>GtkPicture</tt>.
pictureGetPaintable :: (HasCallStack, MonadIO m, IsPicture a) => a -> m (Maybe Paintable)

-- | Creates a new empty <tt>GtkPicture</tt> widget.
pictureNew :: (HasCallStack, MonadIO m) => m Picture

-- | Creates a new <tt>GtkPicture</tt> displaying the given
--   <i><tt>file</tt></i>.
--   
--   If the file isn’t found or can’t be loaded, the resulting
--   <tt>GtkPicture</tt> is empty.
--   
--   If you need to detect failures to load the file, use an image loading
--   framework such as libglycin to load the file yourself, then create the
--   <tt>GtkPicture</tt> from the texture.
pictureNewForFile :: (HasCallStack, MonadIO m, IsFile a) => Maybe a -> m Picture

-- | Creates a new <tt>GtkPicture</tt> displaying the file
--   <i><tt>filename</tt></i>.
--   
--   This is a utility function that calls <a>pictureNewForFile</a>. See
--   that function for details.
pictureNewForFilename :: (HasCallStack, MonadIO m) => Maybe [Char] -> m Picture

-- | Creates a new <tt>GtkPicture</tt> displaying
--   <i><tt>paintable</tt></i>.
--   
--   The <tt>GtkPicture</tt> will track changes to the
--   <i><tt>paintable</tt></i> and update its size and contents in response
--   to it.
pictureNewForPaintable :: (HasCallStack, MonadIO m, IsPaintable a) => Maybe a -> m Picture

-- | Creates a new <tt>GtkPicture</tt> displaying <i><tt>pixbuf</tt></i>.
--   
--   This is a utility function that calls <a>pictureNewForPaintable</a>,
--   See that function for details.
--   
--   The pixbuf must not be modified after passing it to this function.

-- | <i>Deprecated: (Since version 4.12)Use <a>pictureNewForPaintable</a>
--   and<a>textureNewForPixbuf</a> instead</i>
pictureNewForPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => Maybe a -> m Picture

-- | Creates a new <tt>GtkPicture</tt> displaying the resource at
--   <i><tt>resourcePath</tt></i>.
--   
--   This is a utility function that calls <a>pictureNewForFile</a>. See
--   that function for details.
pictureNewForResource :: (HasCallStack, MonadIO m) => Maybe Text -> m Picture

-- | Sets an alternative textual description for the picture contents.
--   
--   It is equivalent to the "alt" attribute for images on websites.
--   
--   This text will be made available to accessibility tools.
--   
--   If the picture cannot be described textually, set this property to
--   <a>Nothing</a>.
pictureSetAlternativeText :: (HasCallStack, MonadIO m, IsPicture a) => a -> Maybe Text -> m ()

-- | If set to <a>True</a>, then <i><tt>self</tt></i> can be made smaller
--   than its contents.
--   
--   The contents will then be scaled down when rendering.
--   
--   If you want to still force a minimum size manually, consider using
--   <a>widgetSetSizeRequest</a>.
--   
--   Also of note is that a similar function for growing does not exist
--   because the grow behavior can be controlled via <a>widgetSetHalign</a>
--   and <a>widgetSetValign</a>.
pictureSetCanShrink :: (HasCallStack, MonadIO m, IsPicture a) => a -> Bool -> m ()

-- | Sets how the content should be resized to fit the <tt>GtkPicture</tt>.
--   
--   See <a>ContentFit</a> for details.
--   
--   <i>Since: 4.8</i>
pictureSetContentFit :: (HasCallStack, MonadIO m, IsPicture a) => a -> ContentFit -> m ()

-- | Makes <i><tt>self</tt></i> load and display <i><tt>file</tt></i>.
--   
--   See <a>pictureNewForFile</a> for details.
--   
--   ::: warning Note that this function should not be used with untrusted
--   data. Use a proper image loading framework such as libglycin, which
--   can load many image formats into a <tt>GdkTexture</tt>, and then use
--   <a>imageSetFromPaintable</a>.
pictureSetFile :: (HasCallStack, MonadIO m, IsPicture a, IsFile b) => a -> Maybe b -> m ()

-- | Makes <i><tt>self</tt></i> load and display the given
--   <i><tt>filename</tt></i>.
--   
--   This is a utility function that calls <a>pictureSetFile</a>.
--   
--   ::: warning Note that this function should not be used with untrusted
--   data. Use a proper image loading framework such as libglycin, which
--   can load many image formats into a <tt>GdkTexture</tt>, and then use
--   <a>imageSetFromPaintable</a>.
pictureSetFilename :: (HasCallStack, MonadIO m, IsPicture a) => a -> Maybe [Char] -> m ()

-- | If set to true, then the contents will be rendered individually.
--   
--   If set to false they will be able to erase or otherwise mix with the
--   background.
--   
--   GTK supports finer grained isolation, in rare cases where you need
--   this, you can use <a>snapshotPushIsolation</a> yourself to achieve
--   this.
--   
--   By default contents are isolated.
--   
--   <i>Since: 4.22</i>
pictureSetIsolateContents :: (HasCallStack, MonadIO m, IsPicture a) => a -> Bool -> m ()

-- | If set to <a>True</a>, the <i><tt>self</tt></i> will render its
--   contents according to their aspect ratio.
--   
--   That means that empty space may show up at the top/bottom or
--   left/right of <i><tt>self</tt></i>.
--   
--   If set to <a>False</a> or if the contents provide no aspect ratio, the
--   contents will be stretched over the picture's whole area.

-- | <i>Deprecated: (Since version 4.8)Use <a>pictureSetContentFit</a>
--   instead. If stillused, this method will always set the
--   <a>Picture:contentFit</a>property to <tt>GTK_CONTENT_FIT_CONTAIN</tt>
--   if <i><tt>keepAspectRatio</tt></i> is true,otherwise it will set it to
--   <tt>GTK_CONTENT_FIT_FILL</tt>.</i>
pictureSetKeepAspectRatio :: (HasCallStack, MonadIO m, IsPicture a) => a -> Bool -> m ()

-- | Makes <i><tt>self</tt></i> display the given
--   <i><tt>paintable</tt></i>.
--   
--   If <i><tt>paintable</tt></i> is <tt>NULL</tt>, nothing will be
--   displayed.
--   
--   See <a>pictureNewForPaintable</a> for details.
pictureSetPaintable :: (HasCallStack, MonadIO m, IsPicture a, IsPaintable b) => a -> Maybe b -> m ()

-- | Sets a <tt>GtkPicture</tt> to show a <tt>GdkPixbuf</tt>.
--   
--   See <a>pictureNewForPixbuf</a> for details.
--   
--   This is a utility function that calls <a>pictureSetPaintable</a>.

-- | <i>Deprecated: (Since version 4.12)Use <a>pictureSetPaintable</a>
--   instead</i>
pictureSetPixbuf :: (HasCallStack, MonadIO m, IsPicture a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Makes <i><tt>self</tt></i> load and display the resource at the given
--   <i><tt>resourcePath</tt></i>.
--   
--   This is a utility function that calls <a>pictureSetFile</a>.
pictureSetResource :: (HasCallStack, MonadIO m, IsPicture a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>alternative-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #alternativeText
--   </pre>
clearPictureAlternativeText :: (MonadIO m, IsPicture o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>alternative-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPictureAlternativeText :: (IsPicture o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>alternative-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> picture #alternativeText
--   </pre>
getPictureAlternativeText :: (MonadIO m, IsPicture o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>alternative-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> picture [ #alternativeText <a>:=</a> value ]
--   </pre>
setPictureAlternativeText :: (MonadIO m, IsPicture o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-shrink</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPictureCanShrink :: (IsPicture o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-shrink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> picture #canShrink
--   </pre>
getPictureCanShrink :: (MonadIO m, IsPicture o) => o -> m Bool

-- | Set the value of the “<tt>can-shrink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> picture [ #canShrink <a>:=</a> value ]
--   </pre>
setPictureCanShrink :: (MonadIO m, IsPicture o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>content-fit</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPictureContentFit :: (IsPicture o, MonadIO m) => ContentFit -> m (GValueConstruct o)

-- | Get the value of the “<tt>content-fit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> picture #contentFit
--   </pre>
getPictureContentFit :: (MonadIO m, IsPicture o) => o -> m ContentFit

-- | Set the value of the “<tt>content-fit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> picture [ #contentFit <a>:=</a> value ]
--   </pre>
setPictureContentFit :: (MonadIO m, IsPicture o) => o -> ContentFit -> m ()

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearPictureFile :: (MonadIO m, IsPicture o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPictureFile :: (IsPicture o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> picture #file
--   </pre>
getPictureFile :: (MonadIO m, IsPicture o) => o -> m (Maybe File)

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> picture [ #file <a>:=</a> value ]
--   </pre>
setPictureFile :: (MonadIO m, IsPicture o, IsFile a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>isolate-contents</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPictureIsolateContents :: (IsPicture o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>isolate-contents</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> picture #isolateContents
--   </pre>
getPictureIsolateContents :: (MonadIO m, IsPicture o) => o -> m Bool

-- | Set the value of the “<tt>isolate-contents</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> picture [ #isolateContents <a>:=</a> value ]
--   </pre>
setPictureIsolateContents :: (MonadIO m, IsPicture o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>keep-aspect-ratio</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPictureKeepAspectRatio :: (IsPicture o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>keep-aspect-ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> picture #keepAspectRatio
--   </pre>
getPictureKeepAspectRatio :: (MonadIO m, IsPicture o) => o -> m Bool

-- | Set the value of the “<tt>keep-aspect-ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> picture [ #keepAspectRatio <a>:=</a> value ]
--   </pre>
setPictureKeepAspectRatio :: (MonadIO m, IsPicture o) => o -> Bool -> m ()

-- | Set the value of the “<tt>paintable</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #paintable
--   </pre>
clearPicturePaintable :: (MonadIO m, IsPicture o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paintable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPicturePaintable :: (IsPicture o, MonadIO m, IsPaintable a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> picture #paintable
--   </pre>
getPicturePaintable :: (MonadIO m, IsPicture o) => o -> m (Maybe Paintable)

-- | Set the value of the “<tt>paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> picture [ #paintable <a>:=</a> value ]
--   </pre>
setPicturePaintable :: (MonadIO m, IsPicture o, IsPaintable a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Picture.Picture
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Picture.Picture
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Picture.Picture
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Picture.Picture)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Picture.Picture o) => GI.Gtk.Objects.Picture.IsPicture o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Picture.Picture
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Picture.Picture


-- | A single-line text entry widget for entering passwords and other
--   secrets.
--   
--   &lt;picture&gt; &lt;source srcset="password-entry-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPasswordEntry" src="password-entry.png"&gt; &lt;/picture&gt;
--   
--   It does not show its contents in clear text, does not allow to copy it
--   to the clipboard, and it shows a warning when Caps Lock is engaged. If
--   the underlying platform allows it, <tt>GtkPasswordEntry</tt> will also
--   place the text in a non-pageable memory area, to avoid it being
--   written out to disk by the operating system.
--   
--   Optionally, it can offer a way to reveal the contents in clear text.
--   
--   <tt>GtkPasswordEntry</tt> provides only minimal API and should be used
--   with the <a>Editable</a> API.
--   
--   <h1>CSS Nodes</h1>
--   
--   <pre>
--   entry.password
--   ╰── text
--       ├── image.caps-lock-indicator
--       ┊
--   </pre>
--   
--   <tt>GtkPasswordEntry</tt> has a single CSS node with name entry that
--   carries a .passwordstyle class. The text Css node below it has a child
--   with name image and style class .caps-lock-indicator for the Caps Lock
--   icon, and possibly other children.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkPasswordEntry</tt> uses the <a>AccessibleRoleTextBox</a> role.
module GI.Gtk.Objects.PasswordEntry

-- | Memory-managed wrapper type.
newtype PasswordEntry
PasswordEntry :: ManagedPtr PasswordEntry -> PasswordEntry

-- | Type class for types which can be safely cast to <a>PasswordEntry</a>,
--   for instance with <a>toPasswordEntry</a>.
class (GObject o, IsDescendantOf PasswordEntry o) => IsPasswordEntry o

-- | Cast to <a>PasswordEntry</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPasswordEntry :: (MonadIO m, IsPasswordEntry o) => o -> m PasswordEntry

-- | Gets the menu model set with <a>passwordEntrySetExtraMenu</a>.
passwordEntryGetExtraMenu :: (HasCallStack, MonadIO m, IsPasswordEntry a) => a -> m (Maybe MenuModel)

-- | Returns whether the entry is showing an icon to reveal the contents.
passwordEntryGetShowPeekIcon :: (HasCallStack, MonadIO m, IsPasswordEntry a) => a -> m Bool

-- | Creates a <tt>GtkPasswordEntry</tt>.
passwordEntryNew :: (HasCallStack, MonadIO m) => m PasswordEntry

-- | Sets a menu model to add when constructing the context menu for
--   <i><tt>entry</tt></i>.
passwordEntrySetExtraMenu :: (HasCallStack, MonadIO m, IsPasswordEntry a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets whether the entry should have a clickable icon to reveal the
--   contents.
--   
--   Setting this to <a>False</a> also hides the text again.
passwordEntrySetShowPeekIcon :: (HasCallStack, MonadIO m, IsPasswordEntry a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activates-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPasswordEntryActivatesDefault :: (IsPasswordEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> passwordEntry #activatesDefault
--   </pre>
getPasswordEntryActivatesDefault :: (MonadIO m, IsPasswordEntry o) => o -> m Bool

-- | Set the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> passwordEntry [ #activatesDefault <a>:=</a> value ]
--   </pre>
setPasswordEntryActivatesDefault :: (MonadIO m, IsPasswordEntry o) => o -> Bool -> m ()

-- | Set the value of the “<tt>extra-menu</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #extraMenu
--   </pre>
clearPasswordEntryExtraMenu :: (MonadIO m, IsPasswordEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>extra-menu</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPasswordEntryExtraMenu :: (IsPasswordEntry o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> passwordEntry #extraMenu
--   </pre>
getPasswordEntryExtraMenu :: (MonadIO m, IsPasswordEntry o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> passwordEntry [ #extraMenu <a>:=</a> value ]
--   </pre>
setPasswordEntryExtraMenu :: (MonadIO m, IsPasswordEntry o, IsMenuModel a) => o -> a -> m ()

-- | Set the value of the “<tt>placeholder-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #placeholderText
--   </pre>
clearPasswordEntryPlaceholderText :: (MonadIO m, IsPasswordEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>placeholder-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPasswordEntryPlaceholderText :: (IsPasswordEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> passwordEntry #placeholderText
--   </pre>
getPasswordEntryPlaceholderText :: (MonadIO m, IsPasswordEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> passwordEntry [ #placeholderText <a>:=</a> value ]
--   </pre>
setPasswordEntryPlaceholderText :: (MonadIO m, IsPasswordEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-peek-icon</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPasswordEntryShowPeekIcon :: (IsPasswordEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-peek-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> passwordEntry #showPeekIcon
--   </pre>
getPasswordEntryShowPeekIcon :: (MonadIO m, IsPasswordEntry o) => o -> m Bool

-- | Set the value of the “<tt>show-peek-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> passwordEntry [ #showPeekIcon <a>:=</a> value ]
--   </pre>
setPasswordEntryShowPeekIcon :: (MonadIO m, IsPasswordEntry o) => o -> Bool -> m ()

-- | Emitted when the entry is activated.
--   
--   The keybindings for this signal are all forms of the Enter key.
type PasswordEntryActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> passwordEntry #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPasswordEntryActivate :: (IsPasswordEntry a, MonadIO m) => a -> ((?self :: a) => PasswordEntryActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> passwordEntry #activate callback
--   </pre>
onPasswordEntryActivate :: (IsPasswordEntry a, MonadIO m) => a -> ((?self :: a) => PasswordEntryActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.PasswordEntry.PasswordEntry
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PasswordEntry.PasswordEntry
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PasswordEntry.PasswordEntry
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PasswordEntry.PasswordEntry)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PasswordEntry.PasswordEntry o) => GI.Gtk.Objects.PasswordEntry.IsPasswordEntry o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PasswordEntry.PasswordEntry
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PasswordEntry.PasswordEntry


-- | Arranges its children in two panes, horizontally or vertically.
--   
--   &lt;picture&gt; &lt;source srcset="panes-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPaned" src="panes.png"&gt; &lt;/picture&gt;
--   
--   The division between the two panes is adjustable by the user by
--   dragging a handle.
--   
--   Child widgets are added to the panes of the widget with
--   <a>panedSetStartChild</a> and <a>panedSetEndChild</a>. The division
--   between the two children is set by default from the size requests of
--   the children, but it can be adjusted by the user.
--   
--   A paned widget draws a separator between the two child widgets and a
--   small handle that the user can drag to adjust the division. It does
--   not draw any relief around the children or around the separator. (The
--   space in which the separator is called the gutter.) Often, it is
--   useful to put each child inside a <a>Frame</a> so that the gutter
--   appears as a ridge. No separator is drawn if one of the children is
--   missing.
--   
--   Each child has two options that can be set, "resize" and "shrink". If
--   "resize" is true then, when the <tt>GtkPaned</tt> is resized, that
--   child will expand or shrink along with the paned widget. If "shrink"
--   is true, then that child can be made smaller than its requisition by
--   the user. Setting "shrink" to false allows the application to set a
--   minimum size. If "resize" is false for both children, then this is
--   treated as if "resize" is true for both children.
--   
--   The application can set the position of the slider as if it were set
--   by the user, by calling <a>panedSetPosition</a>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>Paned::acceptPosition</a></li>
--   <li><a>Paned::cancelPosition</a></li>
--   <li><a>Paned::cycleChildFocus</a></li>
--   <li><a>Paned::cycleHandleFocus</a></li>
--   <li><a>Paned::moveHandle</a></li>
--   <li><a>Paned::toggleHandleFocus</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   paned
--   ├── &lt;child&gt;
--   ├── separator[.wide]
--   ╰── &lt;child&gt;
--   </pre>
--   
--   <tt>GtkPaned</tt> has a main CSS node with name paned, and a subnode
--   for the separator with name separator. The subnode gets a .wide style
--   class when the paned is supposed to be wide.
--   
--   In horizontal orientation, the nodes are arranged based on the text
--   direction, so in left-to-right mode, :first-child will select the
--   leftmost child, while it will select the rightmost child in RTL
--   layouts.
--   
--   <h2>Creating a paned widget with minimum sizes.</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
--   GtkWidget *frame1 = gtk_frame_new (NULL);
--   GtkWidget *frame2 = gtk_frame_new (NULL);
--   
--   gtk_widget_set_size_request (hpaned, 200, -1);
--   
--   gtk_paned_set_start_child (GTK_PANED (hpaned), frame1);
--   gtk_paned_set_resize_start_child (GTK_PANED (hpaned), TRUE);
--   gtk_paned_set_shrink_start_child (GTK_PANED (hpaned), FALSE);
--   gtk_widget_set_size_request (frame1, 50, -1);
--   
--   gtk_paned_set_end_child (GTK_PANED (hpaned), frame2);
--   gtk_paned_set_resize_end_child (GTK_PANED (hpaned), FALSE);
--   gtk_paned_set_shrink_end_child (GTK_PANED (hpaned), FALSE);
--   gtk_widget_set_size_request (frame2, 50, -1);
--   </pre>
module GI.Gtk.Objects.Paned

-- | Memory-managed wrapper type.
newtype Paned
Paned :: ManagedPtr Paned -> Paned

-- | Type class for types which can be safely cast to <a>Paned</a>, for
--   instance with <a>toPaned</a>.
class (GObject o, IsDescendantOf Paned o) => IsPaned o

-- | Cast to <a>Paned</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toPaned :: (MonadIO m, IsPaned o) => o -> m Paned

-- | Retrieves the end child of the given <tt>GtkPaned</tt>.
panedGetEndChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> m (Maybe Widget)

-- | Obtains the position of the divider between the two panes.
panedGetPosition :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Int32

-- | Returns whether the <a>Paned:endChild</a> can be resized.
panedGetResizeEndChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Bool

-- | Returns whether the <a>Paned:startChild</a> can be resized.
panedGetResizeStartChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Bool

-- | Returns whether the <a>Paned:endChild</a> can shrink.
panedGetShrinkEndChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Bool

-- | Returns whether the <a>Paned:startChild</a> can shrink.
panedGetShrinkStartChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Bool

-- | Retrieves the start child of the given <tt>GtkPaned</tt>.
panedGetStartChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> m (Maybe Widget)

-- | Gets whether the separator should be wide.
panedGetWideHandle :: (HasCallStack, MonadIO m, IsPaned a) => a -> m Bool

-- | Creates a new <tt>GtkPaned</tt> widget.
panedNew :: (HasCallStack, MonadIO m) => Orientation -> m Paned

-- | Sets the end child of <i><tt>paned</tt></i> to <i><tt>child</tt></i>.
--   
--   If <i><tt>child</tt></i> is <tt>NULL</tt>, the existing child will be
--   removed.
panedSetEndChild :: (HasCallStack, MonadIO m, IsPaned a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the position of the divider between the two panes.
panedSetPosition :: (HasCallStack, MonadIO m, IsPaned a) => a -> Int32 -> m ()

-- | Sets whether the <a>Paned:endChild</a> can be resized.
panedSetResizeEndChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> Bool -> m ()

-- | Sets whether the <a>Paned:startChild</a> can be resized.
panedSetResizeStartChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> Bool -> m ()

-- | Sets whether the <a>Paned:endChild</a> can shrink.
panedSetShrinkEndChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> Bool -> m ()

-- | Sets whether the <a>Paned:startChild</a> can shrink.
panedSetShrinkStartChild :: (HasCallStack, MonadIO m, IsPaned a) => a -> Bool -> m ()

-- | Sets the start child of <i><tt>paned</tt></i> to
--   <i><tt>child</tt></i>.
--   
--   If <i><tt>child</tt></i> is <tt>NULL</tt>, the existing child will be
--   removed.
panedSetStartChild :: (HasCallStack, MonadIO m, IsPaned a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the separator should be wide.
panedSetWideHandle :: (HasCallStack, MonadIO m, IsPaned a) => a -> Bool -> m ()

-- | Set the value of the “<tt>end-child</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #endChild
--   </pre>
clearPanedEndChild :: (MonadIO m, IsPaned o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>end-child</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPanedEndChild :: (IsPaned o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>end-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #endChild
--   </pre>
getPanedEndChild :: (MonadIO m, IsPaned o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>end-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #endChild <a>:=</a> value ]
--   </pre>
setPanedEndChild :: (MonadIO m, IsPaned o, IsWidget a) => o -> a -> m ()

-- | Get the value of the “<tt>max-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #maxPosition
--   </pre>
getPanedMaxPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Get the value of the “<tt>min-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #minPosition
--   </pre>
getPanedMinPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>position</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPanedPosition :: (IsPaned o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #position
--   </pre>
getPanedPosition :: (MonadIO m, IsPaned o) => o -> m Int32

-- | Set the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #position <a>:=</a> value ]
--   </pre>
setPanedPosition :: (MonadIO m, IsPaned o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>position-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPanedPositionSet :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>position-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #positionSet
--   </pre>
getPanedPositionSet :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>position-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #positionSet <a>:=</a> value ]
--   </pre>
setPanedPositionSet :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resize-end-child</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPanedResizeEndChild :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resize-end-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #resizeEndChild
--   </pre>
getPanedResizeEndChild :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>resize-end-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #resizeEndChild <a>:=</a> value ]
--   </pre>
setPanedResizeEndChild :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resize-start-child</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPanedResizeStartChild :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resize-start-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #resizeStartChild
--   </pre>
getPanedResizeStartChild :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>resize-start-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #resizeStartChild <a>:=</a> value ]
--   </pre>
setPanedResizeStartChild :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shrink-end-child</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructPanedShrinkEndChild :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>shrink-end-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #shrinkEndChild
--   </pre>
getPanedShrinkEndChild :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>shrink-end-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #shrinkEndChild <a>:=</a> value ]
--   </pre>
setPanedShrinkEndChild :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shrink-start-child</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructPanedShrinkStartChild :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>shrink-start-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #shrinkStartChild
--   </pre>
getPanedShrinkStartChild :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>shrink-start-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #shrinkStartChild <a>:=</a> value ]
--   </pre>
setPanedShrinkStartChild :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Set the value of the “<tt>start-child</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #startChild
--   </pre>
clearPanedStartChild :: (MonadIO m, IsPaned o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>start-child</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPanedStartChild :: (IsPaned o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>start-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #startChild
--   </pre>
getPanedStartChild :: (MonadIO m, IsPaned o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>start-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #startChild <a>:=</a> value ]
--   </pre>
setPanedStartChild :: (MonadIO m, IsPaned o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wide-handle</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPanedWideHandle :: (IsPaned o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wide-handle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paned #wideHandle
--   </pre>
getPanedWideHandle :: (MonadIO m, IsPaned o) => o -> m Bool

-- | Set the value of the “<tt>wide-handle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paned [ #wideHandle <a>:=</a> value ]
--   </pre>
setPanedWideHandle :: (MonadIO m, IsPaned o) => o -> Bool -> m ()

-- | Emitted to accept the current position of the handle when moving it
--   using key bindings.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;Return&lt;/kbd&gt;
--   or &lt;kbd&gt;Space&lt;/kbd&gt;.
type PanedAcceptPositionCallback = IO Bool

-- | Connect a signal handler for the <a>acceptPosition</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #acceptPosition callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedAcceptPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedAcceptPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>acceptPosition</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #acceptPosition callback
--   </pre>
onPanedAcceptPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedAcceptPositionCallback) -> m SignalHandlerId

-- | Emitted to cancel moving the position of the handle using key
--   bindings.
--   
--   The position of the handle will be reset to the value prior to moving
--   it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;Escape&lt;/kbd&gt;.
type PanedCancelPositionCallback = IO Bool

-- | Connect a signal handler for the <a>cancelPosition</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #cancelPosition callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedCancelPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCancelPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancelPosition</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #cancelPosition callback
--   </pre>
onPanedCancelPosition :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCancelPositionCallback) -> m SignalHandlerId

-- | Emitted to cycle the focus between the children of the paned.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding is &lt;kbd&gt;F6&lt;/kbd&gt;.
type PanedCycleChildFocusCallback = Bool -> IO Bool

-- | Connect a signal handler for the <a>cycleChildFocus</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #cycleChildFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedCycleChildFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleChildFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleChildFocus</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #cycleChildFocus callback
--   </pre>
onPanedCycleChildFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleChildFocusCallback) -> m SignalHandlerId

-- | Emitted to cycle whether the paned should grab focus to allow the user
--   to change position of the handle by using key bindings.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is &lt;kbd&gt;F8&lt;/kbd&gt;.
type PanedCycleHandleFocusCallback = Bool -> IO Bool

-- | Connect a signal handler for the <a>cycleHandleFocus</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #cycleHandleFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedCycleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cycleHandleFocus</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #cycleHandleFocus callback
--   </pre>
onPanedCycleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedCycleHandleFocusCallback) -> m SignalHandlerId

-- | Emitted to move the handle with key bindings.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;,
--   &lt;kbd&gt;←&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;↑&lt;/kbd&gt;,
--   &lt;kbd&gt;↑&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;↓&lt;/kbd&gt;,
--   &lt;kbd&gt;↓&lt;/kbd&gt;, &lt;kbd&gt;PgUp&lt;/kbd&gt;,
--   &lt;kbd&gt;PgDn&lt;/kbd&gt;, &lt;kbd&gt;Home&lt;/kbd&gt;,
--   &lt;kbd&gt;End&lt;/kbd&gt;.
type PanedMoveHandleCallback = ScrollType -> IO Bool

-- | Connect a signal handler for the <a>moveHandle</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> paned #moveHandle callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedMoveHandle :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedMoveHandleCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveHandle</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> paned #moveHandle callback
--   </pre>
onPanedMoveHandle :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedMoveHandleCallback) -> m SignalHandlerId

-- | Emitted to accept the current position of the handle and then move
--   focus to the next widget in the focus chain.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding is &lt;kbd&gt;Tab&lt;/kbd&gt;.
type PanedToggleHandleFocusCallback = IO Bool

-- | Connect a signal handler for the <a>toggleHandleFocus</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> paned #toggleHandleFocus callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterPanedToggleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedToggleHandleFocusCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleHandleFocus</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> paned #toggleHandleFocus callback
--   </pre>
onPanedToggleHandleFocus :: (IsPaned a, MonadIO m) => a -> ((?self :: a) => PanedToggleHandleFocusCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Paned.Paned
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Paned.Paned
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Paned.Paned
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Paned.Paned)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Paned.Paned o) => GI.Gtk.Objects.Paned.IsPaned o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Paned.Paned
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Paned.Paned


-- | Presents a page setup dialog for platforms which don’t provide a
--   native page setup dialog, like Unix.
--   
--   &lt;picture&gt; &lt;source srcset="pagesetupdialog-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkPageSetupUnixDialog" src="pagesetupdialog.png"&gt; &lt;/picture&gt;
--   
--   It can be used very much like any other GTK dialog, at the cost of the
--   portability offered by the high-level printing API in
--   <a>PrintOperation</a>.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkPageSetupUnixDialog</tt> has a single CSS node with the name
--   <tt>window</tt> and style class <tt>.pagesetup</tt>.
module GI.Gtk.Objects.PageSetupUnixDialog

-- | Memory-managed wrapper type.
newtype PageSetupUnixDialog
PageSetupUnixDialog :: ManagedPtr PageSetupUnixDialog -> PageSetupUnixDialog

-- | Type class for types which can be safely cast to
--   <a>PageSetupUnixDialog</a>, for instance with
--   <a>toPageSetupUnixDialog</a>.
class (GObject o, IsDescendantOf PageSetupUnixDialog o) => IsPageSetupUnixDialog o

-- | Cast to <a>PageSetupUnixDialog</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toPageSetupUnixDialog :: (MonadIO m, IsPageSetupUnixDialog o) => o -> m PageSetupUnixDialog

-- | Gets the currently selected page setup from the dialog.
pageSetupUnixDialogGetPageSetup :: (HasCallStack, MonadIO m, IsPageSetupUnixDialog a) => a -> m PageSetup

-- | Gets the current print settings from the dialog.
pageSetupUnixDialogGetPrintSettings :: (HasCallStack, MonadIO m, IsPageSetupUnixDialog a) => a -> m (Maybe PrintSettings)

-- | Creates a new page setup dialog.
pageSetupUnixDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m PageSetupUnixDialog

-- | Sets the <tt>GtkPageSetup</tt> from which the page setup dialog takes
--   its values.
pageSetupUnixDialogSetPageSetup :: (HasCallStack, MonadIO m, IsPageSetupUnixDialog a, IsPageSetup b) => a -> b -> m ()

-- | Sets the <tt>GtkPrintSettings</tt> from which the page setup dialog
--   takes its values.
pageSetupUnixDialogSetPrintSettings :: (HasCallStack, MonadIO m, IsPageSetupUnixDialog a, IsPrintSettings b) => a -> Maybe b -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.PageSetupUnixDialog.PageSetupUnixDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PageSetupUnixDialog.PageSetupUnixDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PageSetupUnixDialog.PageSetupUnixDialog
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PageSetupUnixDialog.PageSetupUnixDialog)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PageSetupUnixDialog.PageSetupUnixDialog o) => GI.Gtk.Objects.PageSetupUnixDialog.IsPageSetupUnixDialog o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PageSetupUnixDialog.PageSetupUnixDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PageSetupUnixDialog.PageSetupUnixDialog


-- | Handles input from the pads found in drawing tablets.
--   
--   Pads are the collection of buttons and tactile sensors often found
--   around the stylus-sensitive area.
--   
--   These buttons and sensors have no implicit meaning, and by default
--   they perform no action. <tt>GtkPadController</tt> is provided to map
--   those to <a>Action</a> objects, thus letting the application give them
--   a more semantic meaning.
--   
--   Buttons and sensors are not constrained to triggering a single action,
--   some <a>InputSourceTabletPad</a> devices feature multiple "modes". All
--   these input elements have one current mode, which may determine the
--   final action being triggered.
--   
--   Pad devices often divide buttons and sensors into groups. All elements
--   in a group share the same current mode, but different groups may have
--   different modes. See <a>devicePadGetNGroups</a> and
--   <a>devicePadGetGroupNModes</a>.
--   
--   Each of the actions that a given button/strip/ring performs for a
--   given mode is defined by a <a>PadActionEntry</a>. It contains an
--   action name that will be looked up in the given <a>ActionGroup</a> and
--   activated whenever the specified input element and mode are triggered.
--   
--   A simple example of <tt>GtkPadController</tt> usage: Assigning button
--   1 in all modes and pad devices to an "invert-selection" action:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkPadActionEntry *pad_actions[] = {
--     { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
--     …
--   };
--   
--   …
--   action_group = g_simple_action_group_new ();
--   action = g_simple_action_new ("pad-actions.invert-selection", NULL);
--   g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
--   g_action_map_add_action (G_ACTION_MAP (action_group), action);
--   …
--   pad_controller = gtk_pad_controller_new (action_group, NULL);
--   </pre>
--   
--   The actions belonging to rings/strips/dials will be activated with a
--   parameter of type <tt><i>G_VARIANT_TYPE_DOUBLE</i></tt> bearing the
--   value of the given axis, it is required that those are made stateful
--   and accepting this <tt>GVariantType</tt>. For rings the value is the
--   angle of the ring position in degrees with 0 facing up. For strips the
--   value is the absolute position on the strip, normalized to the [0.0,
--   1.0] range. For dials the value is the relative movement of the dial,
--   normalized so that the value 120 represents one logical scroll wheel
--   detent in the positive direction. Devices that support high-resolution
--   scrolling may send events with fractions of 120 to signify a smaller
--   motion.
module GI.Gtk.Objects.PadController

-- | Memory-managed wrapper type.
newtype PadController
PadController :: ManagedPtr PadController -> PadController

-- | Type class for types which can be safely cast to <a>PadController</a>,
--   for instance with <a>toPadController</a>.
class (GObject o, IsDescendantOf PadController o) => IsPadController o

-- | Cast to <a>PadController</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPadController :: (MonadIO m, IsPadController o) => o -> m PadController

-- | Creates a new <tt>GtkPadController</tt> that will associate events
--   from <i><tt>pad</tt></i> to actions.
--   
--   A <a>Nothing</a> pad may be provided so the controller manages all pad
--   devices generically, it is discouraged to mix
--   <tt>GtkPadController</tt> objects with <a>Nothing</a> and
--   non-<a>Nothing</a> <i><tt>pad</tt></i> argument on the same toplevel
--   window, as execution order is not guaranteed.
--   
--   The <tt>GtkPadController</tt> is created with no mapped actions. In
--   order to map pad events to actions, use
--   <a>padControllerSetActionEntries</a> or <a>padControllerSetAction</a>.
--   
--   Be aware that pad events will only be delivered to
--   <tt>GtkWindow</tt>s, so adding a pad controller to any other type of
--   widget will not have an effect.
padControllerNew :: (HasCallStack, MonadIO m, IsActionGroup a, IsDevice b) => a -> Maybe b -> m PadController

-- | Adds an individual action to <i><tt>controller</tt></i>.
--   
--   This action will only be activated if the given button/ring/strip
--   number in <i><tt>index</tt></i> is interacted while the current mode
--   is <i><tt>mode</tt></i>. -1 may be used for simple cases, so the
--   action is triggered on all modes.
--   
--   The given <i><tt>label</tt></i> should be considered user-visible, so
--   internationalization rules apply. Some windowing systems may be able
--   to use those for user feedback.
padControllerSetAction :: (HasCallStack, MonadIO m, IsPadController a) => a -> PadActionType -> Int32 -> Int32 -> Text -> Text -> m ()

-- | A convenience function to add a group of action entries on
--   <i><tt>controller</tt></i>.
--   
--   See <a>PadActionEntry</a> and <a>padControllerSetAction</a>.
padControllerSetActionEntries :: (HasCallStack, MonadIO m, IsPadController a) => a -> [PadActionEntry] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-group</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPadControllerActionGroup :: (IsPadController o, MonadIO m, IsActionGroup a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>action-group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padController #actionGroup
--   </pre>
getPadControllerActionGroup :: (MonadIO m, IsPadController o) => o -> m (Maybe ActionGroup)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructPadControllerPad :: (IsPadController o, MonadIO m, IsDevice a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>pad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> padController #pad
--   </pre>
getPadControllerPad :: (MonadIO m, IsPadController o) => o -> m (Maybe Device)
instance GHC.Classes.Eq GI.Gtk.Objects.PadController.PadController
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.PadController.PadController
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.PadController.PadController
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.PadController.PadController)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.PadController.PadController o) => GI.Gtk.Objects.PadController.IsPadController o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.PadController.PadController
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.PadController.PadController


-- | <tt>GtkLayoutChild</tt> subclass for children in a
--   <tt>GtkOverlayLayout</tt>.
module GI.Gtk.Objects.OverlayLayoutChild

-- | Memory-managed wrapper type.
newtype OverlayLayoutChild
OverlayLayoutChild :: ManagedPtr OverlayLayoutChild -> OverlayLayoutChild

-- | Type class for types which can be safely cast to
--   <a>OverlayLayoutChild</a>, for instance with
--   <a>toOverlayLayoutChild</a>.
class (GObject o, IsDescendantOf OverlayLayoutChild o) => IsOverlayLayoutChild o

-- | Cast to <a>OverlayLayoutChild</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toOverlayLayoutChild :: (MonadIO m, IsOverlayLayoutChild o) => o -> m OverlayLayoutChild

-- | Retrieves whether the child is clipped.
overlayLayoutChildGetClipOverlay :: (HasCallStack, MonadIO m, IsOverlayLayoutChild a) => a -> m Bool

-- | Retrieves whether the child is measured.
overlayLayoutChildGetMeasure :: (HasCallStack, MonadIO m, IsOverlayLayoutChild a) => a -> m Bool

-- | Sets whether to clip this child.
overlayLayoutChildSetClipOverlay :: (HasCallStack, MonadIO m, IsOverlayLayoutChild a) => a -> Bool -> m ()

-- | Sets whether to measure this child.
overlayLayoutChildSetMeasure :: (HasCallStack, MonadIO m, IsOverlayLayoutChild a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>clip-overlay</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructOverlayLayoutChildClipOverlay :: (IsOverlayLayoutChild o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>clip-overlay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> overlayLayoutChild #clipOverlay
--   </pre>
getOverlayLayoutChildClipOverlay :: (MonadIO m, IsOverlayLayoutChild o) => o -> m Bool

-- | Set the value of the “<tt>clip-overlay</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> overlayLayoutChild [ #clipOverlay <a>:=</a> value ]
--   </pre>
setOverlayLayoutChildClipOverlay :: (MonadIO m, IsOverlayLayoutChild o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>measure</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructOverlayLayoutChildMeasure :: (IsOverlayLayoutChild o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>measure</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> overlayLayoutChild #measure
--   </pre>
getOverlayLayoutChildMeasure :: (MonadIO m, IsOverlayLayoutChild o) => o -> m Bool

-- | Set the value of the “<tt>measure</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> overlayLayoutChild [ #measure <a>:=</a> value ]
--   </pre>
setOverlayLayoutChildMeasure :: (MonadIO m, IsOverlayLayoutChild o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.OverlayLayoutChild.OverlayLayoutChild
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.OverlayLayoutChild.OverlayLayoutChild
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.OverlayLayoutChild.OverlayLayoutChild
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.OverlayLayoutChild.OverlayLayoutChild)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.OverlayLayoutChild.OverlayLayoutChild o) => GI.Gtk.Objects.OverlayLayoutChild.IsOverlayLayoutChild o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.OverlayLayoutChild.OverlayLayoutChild
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.OverlayLayoutChild.OverlayLayoutChild


-- | The layout manager used by <a>Overlay</a>.
--   
--   It places widgets as overlays on top of the main child.
--   
--   This is not a reusable layout manager, since it expects its widget to
--   be a <tt>GtkOverlay</tt>. It is only listed here so that its layout
--   properties get documented.
module GI.Gtk.Objects.OverlayLayout

-- | Memory-managed wrapper type.
newtype OverlayLayout
OverlayLayout :: ManagedPtr OverlayLayout -> OverlayLayout

-- | Type class for types which can be safely cast to <a>OverlayLayout</a>,
--   for instance with <a>toOverlayLayout</a>.
class (GObject o, IsDescendantOf OverlayLayout o) => IsOverlayLayout o

-- | Cast to <a>OverlayLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toOverlayLayout :: (MonadIO m, IsOverlayLayout o) => o -> m OverlayLayout

-- | Creates a new <tt>GtkOverlayLayout</tt> instance.
overlayLayoutNew :: (HasCallStack, MonadIO m) => m OverlayLayout
instance GHC.Classes.Eq GI.Gtk.Objects.OverlayLayout.OverlayLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.OverlayLayout.OverlayLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.OverlayLayout.OverlayLayout
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.OverlayLayout.OverlayLayout)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.OverlayLayout.OverlayLayout o) => GI.Gtk.Objects.OverlayLayout.IsOverlayLayout o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.OverlayLayout.OverlayLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.OverlayLayout.OverlayLayout


-- | Places “overlay” widgets on top of a single main child.
--   
--   &lt;picture&gt; &lt;source srcset="overlay-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkOverlay" src="overlay.png"&gt; &lt;/picture&gt;
--   
--   The position of each overlay widget is determined by its
--   <a>Widget:halign</a> and <a>Widget:valign</a> properties. E.g. a
--   widget with both alignments set to <a>AlignStart</a> will be placed at
--   the top left corner of the <tt>GtkOverlay</tt> container, whereas an
--   overlay with halign set to <a>AlignCenter</a> and valign set to
--   <a>AlignEnd</a> will be placed a the bottom edge of the
--   <tt>GtkOverlay</tt>, horizontally centered. The position can be
--   adjusted by setting the margin properties of the child to non-zero
--   values.
--   
--   More complicated placement of overlays is possible by connecting to
--   the <a>Overlay::getChildPosition</a> signal.
--   
--   An overlay’s minimum and natural sizes are those of its main child.
--   The sizes of overlay children are not considered when measuring these
--   preferred sizes.
--   
--   <h1>GtkOverlay as GtkBuildable</h1>
--   
--   The <tt>GtkOverlay</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports placing a child as an overlay by specifying
--   “overlay” as the “type” attribute of a <tt>&lt;child&gt;</tt> element.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkOverlay</tt> has a single CSS node with the name “overlay”.
--   Overlay children whose alignments cause them to be positioned at an
--   edge get the style classes “.left”, “.right”, “.top”, and/or “.bottom”
--   according to their position.
module GI.Gtk.Objects.Overlay

-- | Memory-managed wrapper type.
newtype Overlay
Overlay :: ManagedPtr Overlay -> Overlay

-- | Type class for types which can be safely cast to <a>Overlay</a>, for
--   instance with <a>toOverlay</a>.
class (GObject o, IsDescendantOf Overlay o) => IsOverlay o

-- | Cast to <a>Overlay</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toOverlay :: (MonadIO m, IsOverlay o) => o -> m Overlay

-- | Adds <i><tt>widget</tt></i> to <i><tt>overlay</tt></i>.
--   
--   The widget will be stacked on top of the main widget added with
--   <a>overlaySetChild</a>.
--   
--   The position at which <i><tt>widget</tt></i> is placed is determined
--   from its <a>Widget:halign</a> and <a>Widget:valign</a> properties.
overlayAddOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m ()

-- | Gets the child widget of <i><tt>overlay</tt></i>.
overlayGetChild :: (HasCallStack, MonadIO m, IsOverlay a) => a -> m (Maybe Widget)

-- | Gets whether <i><tt>widget</tt></i> should be clipped within the
--   parent.
overlayGetClipOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m Bool

-- | Gets whether <i><tt>widget</tt></i>'s size is included in the
--   measurement of <i><tt>overlay</tt></i>.
overlayGetMeasureOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m Bool

-- | Creates a new <tt>GtkOverlay</tt>.
overlayNew :: (HasCallStack, MonadIO m) => m Overlay

-- | Removes an overlay that was added with <a>overlayAddOverlay</a>.
overlayRemoveOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> m ()

-- | Sets the child widget of <i><tt>overlay</tt></i>.
overlaySetChild :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether <i><tt>widget</tt></i> should be clipped within the
--   parent.
overlaySetClipOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets whether <i><tt>widget</tt></i> is included in the measured size
--   of <i><tt>overlay</tt></i>.
--   
--   The overlay will request the size of the largest child that has this
--   property set to <a>True</a>. Children who are not included may be
--   drawn outside of <i><tt>overlay</tt></i>'s allocation if they are too
--   large.
overlaySetMeasureOverlay :: (HasCallStack, MonadIO m, IsOverlay a, IsWidget b) => a -> b -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearOverlayChild :: (MonadIO m, IsOverlay o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructOverlayChild :: (IsOverlay o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> overlay #child
--   </pre>
getOverlayChild :: (MonadIO m, IsOverlay o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> overlay [ #child <a>:=</a> value ]
--   </pre>
setOverlayChild :: (MonadIO m, IsOverlay o, IsWidget a) => o -> a -> m ()

-- | Emitted to determine the position and size of any overlay child
--   widgets.
--   
--   A handler for this signal should fill <i><tt>allocation</tt></i> with
--   the desired position and size for <i><tt>widget</tt></i>, relative to
--   the 'main' child of <i><tt>overlay</tt></i>.
--   
--   The default handler for this signal uses the <i><tt>widget</tt></i>'s
--   halign and valign properties to determine the position and gives the
--   widget its natural size (except that an alignment of <a>AlignFill</a>
--   will cause the overlay to be full-width/height). If the main child is
--   a <tt>GtkScrolledWindow</tt>, the overlays are placed relative to its
--   contents.
type OverlayGetChildPositionCallback = Widget -> IO (Bool, Rectangle)

-- | Connect a signal handler for the <a>getChildPosition</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> overlay #getChildPosition callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterOverlayGetChildPosition :: (IsOverlay a, MonadIO m) => a -> ((?self :: a) => OverlayGetChildPositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>getChildPosition</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> overlay #getChildPosition callback
--   </pre>
onOverlayGetChildPosition :: (IsOverlay a, MonadIO m) => a -> ((?self :: a) => OverlayGetChildPositionCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Overlay.Overlay
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Overlay.Overlay
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Overlay.Overlay
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Overlay.Overlay)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Overlay.Overlay o) => GI.Gtk.Objects.Overlay.IsOverlay o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Overlay.Overlay
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Overlay.Overlay


-- | A <tt>GObject</tt> value in a <tt>GtkExpression</tt>.
module GI.Gtk.Objects.ObjectExpression

-- | Memory-managed wrapper type.
newtype ObjectExpression
ObjectExpression :: ManagedPtr ObjectExpression -> ObjectExpression

-- | Type class for types which can be safely cast to
--   <a>ObjectExpression</a>, for instance with <a>toObjectExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ObjectExpression o) => IsObjectExpression o

-- | Cast to <a>ObjectExpression</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toObjectExpression :: (MonadIO m, IsObjectExpression o) => o -> m ObjectExpression

-- | Gets the object that the expression evaluates to.
objectExpressionGetObject :: (HasCallStack, MonadIO m, IsObjectExpression a) => a -> m (Maybe Object)

-- | Creates an expression evaluating to the given <tt>object</tt> with a
--   weak reference.
--   
--   Once the <tt>object</tt> is disposed, it will fail to evaluate.
--   
--   This expression is meant to break reference cycles.
--   
--   If you want to keep a reference to <tt>object</tt>, use
--   <a>ConstantExpression</a>.<tt><i>new</i></tt>().
objectExpressionNew :: (HasCallStack, MonadIO m, IsObject a) => a -> m ObjectExpression
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.ObjectExpression.ObjectExpression
instance GHC.Classes.Eq GI.Gtk.Objects.ObjectExpression.ObjectExpression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ObjectExpression.ObjectExpression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ObjectExpression.ObjectExpression o) => GI.Gtk.Objects.ObjectExpression.IsObjectExpression o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ObjectExpression.ObjectExpression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ObjectExpression.ObjectExpression


-- | Sorts items numerically.
--   
--   To obtain the numbers to compare, this sorter evaluates a
--   <a>Expression</a>.
module GI.Gtk.Objects.NumericSorter

-- | Memory-managed wrapper type.
newtype NumericSorter
NumericSorter :: ManagedPtr NumericSorter -> NumericSorter

-- | Type class for types which can be safely cast to <a>NumericSorter</a>,
--   for instance with <a>toNumericSorter</a>.
class (GObject o, IsDescendantOf NumericSorter o) => IsNumericSorter o

-- | Cast to <a>NumericSorter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNumericSorter :: (MonadIO m, IsNumericSorter o) => o -> m NumericSorter

-- | Gets the expression that is evaluated to obtain numbers from items.
numericSorterGetExpression :: (HasCallStack, MonadIO m, IsNumericSorter a) => a -> m (Maybe Expression)

-- | Gets whether this sorter will sort smaller numbers first.
numericSorterGetSortOrder :: (HasCallStack, MonadIO m, IsNumericSorter a) => a -> m SortType

-- | Creates a new numeric sorter using the given
--   <i><tt>expression</tt></i>.
--   
--   Smaller numbers will be sorted first. You can call
--   <a>numericSorterSetSortOrder</a> to change this.
numericSorterNew :: (HasCallStack, MonadIO m, IsExpression a) => Maybe a -> m NumericSorter

-- | Sets the expression that is evaluated to obtain numbers from items.
--   
--   Unless an expression is set on <i><tt>self</tt></i>, the sorter will
--   always compare items as invalid.
--   
--   The expression must have a return type that can be compared
--   numerically, such as <tt><i>G_TYPE_INT</i></tt> or
--   <tt><i>G_TYPE_DOUBLE</i></tt>.
numericSorterSetExpression :: (HasCallStack, MonadIO m, IsNumericSorter a, IsExpression b) => a -> Maybe b -> m ()

-- | Sets whether to sort smaller numbers before larger ones.
numericSorterSetSortOrder :: (HasCallStack, MonadIO m, IsNumericSorter a) => a -> SortType -> m ()

-- | Set the value of the “<tt>expression</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #expression
--   </pre>
clearNumericSorterExpression :: (MonadIO m, IsNumericSorter o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expression</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNumericSorterExpression :: (IsNumericSorter o, MonadIO m, IsExpression a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> numericSorter #expression
--   </pre>
getNumericSorterExpression :: (MonadIO m, IsNumericSorter o) => o -> m (Maybe Expression)

-- | Set the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> numericSorter [ #expression <a>:=</a> value ]
--   </pre>
setNumericSorterExpression :: (MonadIO m, IsNumericSorter o, IsExpression a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sort-order</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNumericSorterSortOrder :: (IsNumericSorter o, MonadIO m) => SortType -> m (GValueConstruct o)

-- | Get the value of the “<tt>sort-order</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> numericSorter #sortOrder
--   </pre>
getNumericSorterSortOrder :: (MonadIO m, IsNumericSorter o) => o -> m SortType

-- | Set the value of the “<tt>sort-order</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> numericSorter [ #sortOrder <a>:=</a> value ]
--   </pre>
setNumericSorterSortOrder :: (MonadIO m, IsNumericSorter o) => o -> SortType -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.NumericSorter.NumericSorter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.NumericSorter.NumericSorter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.NumericSorter.NumericSorter
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.NumericSorter.NumericSorter)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.NumericSorter.NumericSorter o) => GI.Gtk.Objects.NumericSorter.IsNumericSorter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.NumericSorter.NumericSorter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.NumericSorter.NumericSorter


-- | Does nothing.
module GI.Gtk.Objects.NothingAction

-- | Memory-managed wrapper type.
newtype NothingAction
NothingAction :: ManagedPtr NothingAction -> NothingAction

-- | Type class for types which can be safely cast to <a>NothingAction</a>,
--   for instance with <a>toNothingAction</a>.
class (GObject o, IsDescendantOf NothingAction o) => IsNothingAction o

-- | Cast to <a>NothingAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNothingAction :: (MonadIO m, IsNothingAction o) => o -> m NothingAction

-- | Gets the nothing action.
--   
--   This is an action that does nothing and where activating it always
--   fails.
nothingActionGet :: (HasCallStack, MonadIO m) => m NothingAction
instance GHC.Classes.Eq GI.Gtk.Objects.NothingAction.NothingAction
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.NothingAction.NothingAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.NothingAction.NothingAction
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.NothingAction.NothingAction)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.NothingAction.NothingAction o) => GI.Gtk.Objects.NothingAction.IsNothingAction o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.NothingAction.NothingAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.NothingAction.NothingAction


-- | An auxiliary object used by <tt>GtkNotebook</tt>.
module GI.Gtk.Objects.NotebookPage

-- | Memory-managed wrapper type.
newtype NotebookPage
NotebookPage :: ManagedPtr NotebookPage -> NotebookPage

-- | Type class for types which can be safely cast to <a>NotebookPage</a>,
--   for instance with <a>toNotebookPage</a>.
class (GObject o, IsDescendantOf NotebookPage o) => IsNotebookPage o

-- | Cast to <a>NotebookPage</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNotebookPage :: (MonadIO m, IsNotebookPage o) => o -> m NotebookPage

-- | Returns the notebook child to which <i><tt>page</tt></i> belongs.
notebookPageGetChild :: (HasCallStack, MonadIO m, IsNotebookPage a) => a -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNotebookPageChild :: (IsNotebookPage o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #child
--   </pre>
getNotebookPageChild :: (MonadIO m, IsNotebookPage o) => o -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>detachable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookPageDetachable :: (IsNotebookPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>detachable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #detachable
--   </pre>
getNotebookPageDetachable :: (MonadIO m, IsNotebookPage o) => o -> m Bool

-- | Set the value of the “<tt>detachable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebookPage [ #detachable <a>:=</a> value ]
--   </pre>
setNotebookPageDetachable :: (MonadIO m, IsNotebookPage o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNotebookPageMenu :: (IsNotebookPage o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #menu
--   </pre>
getNotebookPageMenu :: (MonadIO m, IsNotebookPage o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>menu-label</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuLabel
--   </pre>
clearNotebookPageMenuLabel :: (MonadIO m, IsNotebookPage o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-label</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookPageMenuLabel :: (IsNotebookPage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #menuLabel
--   </pre>
getNotebookPageMenuLabel :: (MonadIO m, IsNotebookPage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>menu-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebookPage [ #menuLabel <a>:=</a> value ]
--   </pre>
setNotebookPageMenuLabel :: (MonadIO m, IsNotebookPage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>position</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookPagePosition :: (IsNotebookPage o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #position
--   </pre>
getNotebookPagePosition :: (MonadIO m, IsNotebookPage o) => o -> m Int32

-- | Set the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebookPage [ #position <a>:=</a> value ]
--   </pre>
setNotebookPagePosition :: (MonadIO m, IsNotebookPage o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNotebookPageReorderable :: (IsNotebookPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #reorderable
--   </pre>
getNotebookPageReorderable :: (MonadIO m, IsNotebookPage o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebookPage [ #reorderable <a>:=</a> value ]
--   </pre>
setNotebookPageReorderable :: (MonadIO m, IsNotebookPage o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNotebookPageTab :: (IsNotebookPage o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #tab
--   </pre>
getNotebookPageTab :: (MonadIO m, IsNotebookPage o) => o -> m (Maybe Widget)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-expand</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookPageTabExpand :: (IsNotebookPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #tabExpand
--   </pre>
getNotebookPageTabExpand :: (MonadIO m, IsNotebookPage o) => o -> m Bool

-- | Set the value of the “<tt>tab-expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebookPage [ #tabExpand <a>:=</a> value ]
--   </pre>
setNotebookPageTabExpand :: (MonadIO m, IsNotebookPage o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-fill</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookPageTabFill :: (IsNotebookPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-fill</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #tabFill
--   </pre>
getNotebookPageTabFill :: (MonadIO m, IsNotebookPage o) => o -> m Bool

-- | Set the value of the “<tt>tab-fill</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebookPage [ #tabFill <a>:=</a> value ]
--   </pre>
setNotebookPageTabFill :: (MonadIO m, IsNotebookPage o) => o -> Bool -> m ()

-- | Set the value of the “<tt>tab-label</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tabLabel
--   </pre>
clearNotebookPageTabLabel :: (MonadIO m, IsNotebookPage o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-label</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookPageTabLabel :: (IsNotebookPage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebookPage #tabLabel
--   </pre>
getNotebookPageTabLabel :: (MonadIO m, IsNotebookPage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tab-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebookPage [ #tabLabel <a>:=</a> value ]
--   </pre>
setNotebookPageTabLabel :: (MonadIO m, IsNotebookPage o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.NotebookPage.NotebookPage
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.NotebookPage.NotebookPage
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.NotebookPage.NotebookPage
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.NotebookPage.NotebookPage)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.NotebookPage.NotebookPage o) => GI.Gtk.Objects.NotebookPage.IsNotebookPage o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.NotebookPage.NotebookPage
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.NotebookPage.NotebookPage


-- | Switches between children using tabs.
--   
--   &lt;picture&gt; &lt;source srcset="notebook-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkNotebook" src="notebook.png"&gt; &lt;/picture&gt;
--   
--   There are many configuration options for <tt>GtkNotebook</tt>. Among
--   other things, you can choose on which edge the tabs appear (see
--   <a>notebookSetTabPos</a>), whether, if there are too many tabs to fit
--   the notebook should be made bigger or scrolling arrows added (see
--   <a>notebookSetScrollable</a>), and whether there will be a popup menu
--   allowing the users to switch pages. (see <a>notebookPopupEnable</a>).
--   
--   <h1>GtkNotebook as GtkBuildable</h1>
--   
--   The <tt>GtkNotebook</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports placing children into tabs by specifying “tab” as
--   the “type” attribute of a <tt>&lt;child&gt;</tt> element. Note that
--   the content of the tab must be created before the tab can be filled. A
--   tab child can be specified without specifying a <tt>&lt;child&gt;</tt>
--   type attribute.
--   
--   To add a child widget in the notebooks action area, specify
--   "action-start" or “action-end” as the “type” attribute of the
--   <tt>&lt;child&gt;</tt> element.
--   
--   An example of a UI definition fragment with <tt>GtkNotebook</tt>:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkNotebook"&gt;
--     &lt;child&gt;
--       &lt;object class="GtkLabel" id="notebook-content"&gt;
--         &lt;property name="label"&gt;Content&lt;/property&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;child type="tab"&gt;
--       &lt;object class="GtkLabel" id="notebook-tab"&gt;
--         &lt;property name="label"&gt;Tab&lt;/property&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkNotebook</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;F10&lt;/kbd&gt; or
--   &lt;kbd&gt;Menu&lt;/kbd&gt; opens the context menu.</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt; moves the focus to the first tab.</li>
--   <li>&lt;kbd&gt;End&lt;/kbd&gt; moves the focus to the last tab.</li>
--   </ul>
--   
--   Additionally, the following signals have default keybindings:
--   
--   <ul>
--   <li><a>Notebook::changeCurrentPage</a></li>
--   <li><a>Notebook::focusTab</a></li>
--   <li><a>Notebook::moveFocusOut</a></li>
--   <li><a>Notebook::reorderTab</a></li>
--   <li><a>Notebook::selectPage</a></li>
--   </ul>
--   
--   Tabs support drag-and-drop between notebooks sharing the same
--   <tt>group-name</tt>, or to new windows by handling the
--   <tt>::create-window</tt> signal.
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkNotebook</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>menu.popup</tt> opens the tabs context menu.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   notebook
--   ├── header.top
--   │   ├── [&lt;action widget&gt;]
--   │   ├── tabs
--   │   │   ├── [arrow]
--   │   │   ├── tab
--   │   │   │   ╰── &lt;tab label&gt;
--   ┊   ┊   ┊
--   │   │   ├── tab[.reorderable-page]
--   │   │   │   ╰── &lt;tab label&gt;
--   │   │   ╰── [arrow]
--   │   ╰── [&lt;action widget&gt;]
--   │
--   ╰── stack
--       ├── &lt;child&gt;
--       ┊
--       ╰── &lt;child&gt;
--   </pre>
--   
--   <tt>GtkNotebook</tt> has a main CSS node with name <tt>notebook</tt>,
--   a subnode with name <tt>header</tt> and below that a subnode with name
--   <tt>tabs</tt> which contains one subnode per tab with name
--   <tt>tab</tt>.
--   
--   If action widgets are present, their CSS nodes are placed next to the
--   <tt>tabs</tt> node. If the notebook is scrollable, CSS nodes with name
--   <tt>arrow</tt> are placed as first and last child of the <tt>tabs</tt>
--   node.
--   
--   The main node gets the <tt>.frame</tt> style class when the notebook
--   has a border (see <a>notebookSetShowBorder</a>).
--   
--   The header node gets one of the style class <tt>.top</tt>,
--   <tt>.bottom</tt>, <tt>.left</tt> or <tt>.right</tt>, depending on
--   where the tabs are placed. For reorderable pages, the tab node gets
--   the <tt>.reorderable-page</tt> class.
--   
--   A <tt>tab</tt> node gets the <tt>.dnd</tt> style class while it is
--   moved with drag-and-drop.
--   
--   The nodes are always arranged from left-to-right, regardless of text
--   direction.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkNotebook</tt> uses the following roles:
--   
--   <ul>
--   <li><a>AccessibleRoleGroup</a> for the notebook widget</li>
--   <li><a>AccessibleRoleTabList</a> for the list of tabs</li>
--   <li><a>AccessibleRoleTab</a> role for each tab</li>
--   <li><a>AccessibleRoleTabPanel</a> for each page</li>
--   </ul>
module GI.Gtk.Objects.Notebook

-- | Memory-managed wrapper type.
newtype Notebook
Notebook :: ManagedPtr Notebook -> Notebook

-- | Type class for types which can be safely cast to <a>Notebook</a>, for
--   instance with <a>toNotebook</a>.
class (GObject o, IsDescendantOf Notebook o) => IsNotebook o

-- | Cast to <a>Notebook</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toNotebook :: (MonadIO m, IsNotebook o) => o -> m Notebook

-- | Appends a page to <i><tt>notebook</tt></i>.
notebookAppendPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

-- | Appends a page to <i><tt>notebook</tt></i>, specifying the widget to
--   use as the label in the popup menu.
notebookAppendPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> m Int32

-- | Removes the child from the notebook.
--   
--   This function is very similar to <a>notebookRemovePage</a>, but
--   additionally informs the notebook that the removal is happening as
--   part of a tab DND operation, which should not be cancelled.
notebookDetachTab :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m ()

-- | Gets one of the action widgets.
--   
--   See <a>notebookSetActionWidget</a>.
notebookGetActionWidget :: (HasCallStack, MonadIO m, IsNotebook a) => a -> PackType -> m (Maybe Widget)

-- | Returns the page number of the current page.
notebookGetCurrentPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Int32

-- | Gets the current group name for <i><tt>notebook</tt></i>.
notebookGetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m (Maybe Text)

-- | Retrieves the menu label widget of the page containing
--   <i><tt>child</tt></i>.
notebookGetMenuLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Widget)

-- | Retrieves the text of the menu label for the page containing
--   <i><tt>child</tt></i>.
notebookGetMenuLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Text)

-- | Gets the number of pages in a notebook.
notebookGetNPages :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Int32

-- | Returns the child widget contained in page number
--   <i><tt>pageNum</tt></i>.
notebookGetNthPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Int32 -> m (Maybe Widget)

-- | Returns the <tt>GtkNotebookPage</tt> for <i><tt>child</tt></i>.
notebookGetPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m NotebookPage

-- | Returns a <tt>GListModel</tt> that contains the pages of the notebook.
--   
--   This can be used to keep an up-to-date view. The model also implements
--   <a>SelectionModel</a> and can be used to track and modify the visible
--   page.
notebookGetPages :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ListModel

-- | Returns whether the tab label area has arrows for scrolling.
notebookGetScrollable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether a bevel will be drawn around the notebook pages.
notebookGetShowBorder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether the tabs of the notebook are shown.
notebookGetShowTabs :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m Bool

-- | Returns whether the tab contents can be detached from
--   <i><tt>notebook</tt></i>.
notebookGetTabDetachable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Bool

-- | Returns the tab label widget for the page <i><tt>child</tt></i>.
--   
--   <a>Nothing</a> is returned if <i><tt>child</tt></i> is not in
--   <i><tt>notebook</tt></i> or if no tab label has specifically been set
--   for <i><tt>child</tt></i>.
notebookGetTabLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Widget)

-- | Retrieves the text of the tab label for the page containing
--   <i><tt>child</tt></i>.
notebookGetTabLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m (Maybe Text)

-- | Gets the edge at which the tabs are drawn.
notebookGetTabPos :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m PositionType

-- | Gets whether the tab can be reordered via drag and drop or not.
notebookGetTabReorderable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Bool

-- | Insert a page into <i><tt>notebook</tt></i> at the given position.
notebookInsertPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> Int32 -> m Int32

-- | Insert a page into <i><tt>notebook</tt></i> at the given position,
--   specifying the widget to use as the label in the popup menu.
notebookInsertPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> Int32 -> m Int32

-- | Creates a new <tt>GtkNotebook</tt> widget with no pages.
notebookNew :: (HasCallStack, MonadIO m) => m Notebook

-- | Switches to the next page.
--   
--   Nothing happens if the current page is the last page.
notebookNextPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Finds the index of the page which contains the given child widget.
notebookPageNum :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> m Int32

-- | Disables the popup menu.
notebookPopupDisable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Enables the popup menu.
--   
--   If the user clicks with the right mouse button on the tab labels, a
--   menu with all the pages will be popped up.
notebookPopupEnable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Prepends a page to <i><tt>notebook</tt></i>.
notebookPrependPage :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m Int32

-- | Prepends a page to <i><tt>notebook</tt></i>, specifying the widget to
--   use as the label in the popup menu.
notebookPrependPageMenu :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c, IsWidget d) => a -> b -> Maybe c -> Maybe d -> m Int32

-- | Switches to the previous page.
--   
--   Nothing happens if the current page is the first page.
notebookPrevPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> m ()

-- | Removes a page from the notebook given its index in the notebook.
notebookRemovePage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Int32 -> m ()

-- | Reorders the page containing <i><tt>child</tt></i>, so that it appears
--   in position <i><tt>position</tt></i>.
--   
--   If <i><tt>position</tt></i> is greater than or equal to the number of
--   children in the list or negative, <i><tt>child</tt></i> will be moved
--   to the end of the list.
notebookReorderChild :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Sets <i><tt>widget</tt></i> as one of the action widgets.
--   
--   Depending on the pack type the widget will be placed before or after
--   the tabs. You can use a <tt>GtkBox</tt> if you need to pack more than
--   one widget on the same side.
notebookSetActionWidget :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> PackType -> m ()

-- | Switches to the page number <i><tt>pageNum</tt></i>.
--   
--   Note that due to historical reasons, GtkNotebook refuses to switch to
--   a page unless the child widget is visible. Therefore, it is
--   recommended to show child widgets before adding them to a notebook.
notebookSetCurrentPage :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Int32 -> m ()

-- | Sets a group name for <i><tt>notebook</tt></i>.
--   
--   Notebooks with the same name will be able to exchange tabs via drag
--   and drop. A notebook with a <a>Nothing</a> group name will not be able
--   to exchange tabs with any other notebook.
notebookSetGroupName :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Maybe Text -> m ()

-- | Changes the menu label for the page containing <i><tt>child</tt></i>.
notebookSetMenuLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Creates a new label and sets it as the menu label of
--   <i><tt>child</tt></i>.
notebookSetMenuLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets whether the tab label area will have arrows for scrolling if
--   there are too many tabs to fit in the area.
notebookSetScrollable :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Bool -> m ()

-- | Sets whether a bevel will be drawn around the notebook pages.
--   
--   This only has a visual effect when the tabs are not shown.
notebookSetShowBorder :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Bool -> m ()

-- | Sets whether to show the tabs for the notebook or not.
notebookSetShowTabs :: (HasCallStack, MonadIO m, IsNotebook a) => a -> Bool -> m ()

-- | Sets whether the tab can be detached from <i><tt>notebook</tt></i> to
--   another notebook or widget.
--   
--   Note that two notebooks must share a common group identifier (see
--   <a>notebookSetGroupName</a>) to allow automatic tabs interchange
--   between them.
--   
--   If you want a widget to interact with a notebook through DnD (i.e.:
--   accept dragged tabs from it) it must be set as a drop destination by
--   adding to it a <a>DropTarget</a> controller that accepts the GType
--   <tt>GTK_TYPE_NOTEBOOK_PAGE</tt>. The <tt>:value</tt> of said drop
--   target will be preloaded with a <a>NotebookPage</a> object that
--   corresponds to the dropped tab, so you can process the value via
--   <tt>::accept</tt> or <tt>::drop</tt> signals.
--   
--   Note that you should use <a>notebookDetachTab</a> instead of
--   <a>notebookRemovePage</a> if you want to remove the tab from the
--   source notebook as part of accepting a drop. Otherwise, the source
--   notebook will think that the dragged tab was removed from underneath
--   the ongoing drag operation, and will initiate a drag cancel animation.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   on_drag_data_received (GtkWidget        *widget,
--                          GdkDrop          *drop,
--                          GtkSelectionData *data,
--                          guint             time,
--                          gpointer          user_data)
--   {
--     GtkDrag *drag;
--     GtkWidget *notebook;
--     GtkWidget **child;
--   
--     drag = gtk_drop_get_drag (drop);
--     notebook = g_object_get_data (drag, "gtk-notebook-drag-origin");
--     child = (void*) gtk_selection_data_get_data (data);
--   
--     // process_widget (*child);
--   
--     gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
--   }
--   </pre>
--   
--   If you want a notebook to accept drags from other widgets, you will
--   have to set your own DnD code to do it.
notebookSetTabDetachable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Bool -> m ()

-- | Changes the tab label for <i><tt>child</tt></i>.
--   
--   If <a>Nothing</a> is specified for <i><tt>tabLabel</tt></i>, then the
--   page will have the label “page N”.
notebookSetTabLabel :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Creates a new label and sets it as the tab label for the page
--   containing <i><tt>child</tt></i>.
notebookSetTabLabelText :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets the edge at which the tabs are drawn.
notebookSetTabPos :: (HasCallStack, MonadIO m, IsNotebook a) => a -> PositionType -> m ()

-- | Sets whether the notebook tab can be reordered via drag and drop or
--   not.
notebookSetTabReorderable :: (HasCallStack, MonadIO m, IsNotebook a, IsWidget b) => a -> b -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-popup</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNotebookEnablePopup :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-popup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #enablePopup
--   </pre>
getNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>enable-popup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #enablePopup <a>:=</a> value ]
--   </pre>
setNotebookEnablePopup :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Set the value of the “<tt>group-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #groupName
--   </pre>
clearNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookGroupName :: (IsNotebook o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>group-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #groupName
--   </pre>
getNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>group-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #groupName <a>:=</a> value ]
--   </pre>
setNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNotebookPage :: (IsNotebook o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>page</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #page
--   </pre>
getNotebookPage :: (MonadIO m, IsNotebook o) => o -> m Int32

-- | Set the value of the “<tt>page</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #page <a>:=</a> value ]
--   </pre>
setNotebookPage :: (MonadIO m, IsNotebook o) => o -> Int32 -> m ()

-- | Get the value of the “<tt>pages</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #pages
--   </pre>
getNotebookPages :: (MonadIO m, IsNotebook o) => o -> m (Maybe ListModel)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scrollable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookScrollable :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>scrollable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #scrollable
--   </pre>
getNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>scrollable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #scrollable <a>:=</a> value ]
--   </pre>
setNotebookScrollable :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-border</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNotebookShowBorder :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-border</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #showBorder
--   </pre>
getNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>show-border</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #showBorder <a>:=</a> value ]
--   </pre>
setNotebookShowBorder :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-tabs</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructNotebookShowTabs :: (IsNotebook o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-tabs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #showTabs
--   </pre>
getNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> m Bool

-- | Set the value of the “<tt>show-tabs</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #showTabs <a>:=</a> value ]
--   </pre>
setNotebookShowTabs :: (MonadIO m, IsNotebook o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-pos</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNotebookTabPos :: (IsNotebook o, MonadIO m) => PositionType -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> notebook #tabPos
--   </pre>
getNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> m PositionType

-- | Set the value of the “<tt>tab-pos</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> notebook [ #tabPos <a>:=</a> value ]
--   </pre>
setNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> PositionType -> m ()

-- | Emitted when the current page should be changed.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;.
type NotebookChangeCurrentPageCallback = Int32 -> IO Bool

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> notebook #changeCurrentPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changeCurrentPage</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #changeCurrentPage callback
--   </pre>
onNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId

-- | The <a>createWindow</a> signal is emitted when a detachable tab is
--   dropped on the root window.
--   
--   A handler for this signal can create a window containing a notebook
--   where the tab will be attached. It is also responsible for
--   moving/resizing the window and adding the necessary properties to the
--   notebook (e.g. the <tt>GtkNotebook</tt>:group-name ).
type NotebookCreateWindowCallback = Widget -> IO Maybe Notebook

-- | Connect a signal handler for the <a>createWindow</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #createWindow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createWindow</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #createWindow callback
--   </pre>
onNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId

-- | Emitted when a tab should be focused.
type NotebookFocusTabCallback = NotebookTab -> IO Bool

-- | Connect a signal handler for the <a>focusTab</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #focusTab callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusTab</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #focusTab callback
--   </pre>
onNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId

-- | Emitted when focus was moved out.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;↑&lt;/kbd&gt; and
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;↓&lt;/kbd&gt;.
type NotebookMoveFocusOutCallback = DirectionType -> IO ()

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #moveFocusOut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveFocusOut</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #moveFocusOut callback
--   </pre>
onNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId

-- | the <a>pageAdded</a> signal is emitted in the notebook right after a
--   page is added to the notebook.
type NotebookPageAddedCallback = Widget -> Word32 -> IO ()

-- | Connect a signal handler for the <a>pageAdded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #pageAdded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageAdded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #pageAdded callback
--   </pre>
onNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId

-- | the <a>pageRemoved</a> signal is emitted in the notebook right after a
--   page is removed from the notebook.
type NotebookPageRemovedCallback = Widget -> Word32 -> IO ()

-- | Connect a signal handler for the <a>pageRemoved</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #pageRemoved callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageRemoved</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #pageRemoved callback
--   </pre>
onNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId

-- | the <a>pageReordered</a> signal is emitted in the notebook right after
--   a page has been reordered.
type NotebookPageReorderedCallback = Widget -> Word32 -> IO ()

-- | Connect a signal handler for the <a>pageReordered</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> notebook #pageReordered callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pageReordered</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #pageReordered callback
--   </pre>
onNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId

-- | Emitted when the tab should be reordered.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;Home&lt;/kbd&gt;,
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;End&lt;/kbd&gt;,
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgUp&lt;/kbd&gt;,
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;PgDn&lt;/kbd&gt;,
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;,
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;↑&lt;/kbd&gt; and
--   &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;↓&lt;/kbd&gt;.
type NotebookReorderTabCallback = DirectionType -> Bool -> IO Bool

-- | Connect a signal handler for the <a>reorderTab</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #reorderTab callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>reorderTab</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #reorderTab callback
--   </pre>
onNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId

-- | Emitted when a page should be selected.
--   
--   The default binding for this signal is &lt;kbd&gt;␣&lt;/kbd&gt;.
type NotebookSelectPageCallback = Bool -> IO Bool

-- | Connect a signal handler for the <a>selectPage</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #selectPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectPage</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #selectPage callback
--   </pre>
onNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId

-- | Emitted when the user or a function changes the current page.
type NotebookSwitchPageCallback = Widget -> Word32 -> IO ()

-- | Connect a signal handler for the <a>switchPage</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> notebook #switchPage callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>switchPage</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> notebook #switchPage callback
--   </pre>
onNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Notebook.Notebook
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Notebook.Notebook
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Notebook.Notebook
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Notebook.Notebook)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Notebook.Notebook o) => GI.Gtk.Objects.Notebook.IsNotebook o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Notebook.Notebook
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Notebook.Notebook


-- | Base class for platform dialogs that don't use <tt>GtkDialog</tt>.
--   
--   Native dialogs are used in order to integrate better with a platform,
--   by looking the same as other native applications and supporting
--   platform specific features.
--   
--   The <a>Dialog</a> functions cannot be used on such objects, but we
--   need a similar API in order to drive them. The
--   <tt>GtkNativeDialog</tt> object is an API that allows you to do this.
--   It allows you to set various common properties on the dialog, as well
--   as show and hide it and get a <a>NativeDialog::response</a> signal
--   when the user finished with the dialog.
--   
--   Note that unlike <tt>GtkDialog</tt>, <tt>GtkNativeDialog</tt> objects
--   are not toplevel widgets, and GTK does not keep them alive. It is your
--   responsibility to keep a reference until you are done with the object.
module GI.Gtk.Objects.NativeDialog

-- | Memory-managed wrapper type.
newtype NativeDialog
NativeDialog :: ManagedPtr NativeDialog -> NativeDialog

-- | Type class for types which can be safely cast to <a>NativeDialog</a>,
--   for instance with <a>toNativeDialog</a>.
class (GObject o, IsDescendantOf NativeDialog o) => IsNativeDialog o

-- | Cast to <a>NativeDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNativeDialog :: (MonadIO m, IsNativeDialog o) => o -> m NativeDialog

-- | Destroys a dialog.
--   
--   When a dialog is destroyed, it will break any references it holds to
--   other objects.
--   
--   If it is visible it will be hidden and any underlying window system
--   resources will be destroyed.
--   
--   Note that this does not release any reference to the object (as
--   opposed to destroying a <tt>GtkWindow</tt>) because there is no
--   reference from the windowing system to the <tt>GtkNativeDialog</tt>.
nativeDialogDestroy :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Returns whether the dialog is modal.
nativeDialogGetModal :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m Bool

-- | Gets the title of the <tt>GtkNativeDialog</tt>.
nativeDialogGetTitle :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m (Maybe Text)

-- | Fetches the transient parent for this window.
nativeDialogGetTransientFor :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m (Maybe Window)

-- | Determines whether the dialog is visible.
nativeDialogGetVisible :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m Bool

-- | Hides the dialog if it is visible, aborting any interaction.
--   
--   Once this is called the <a>NativeDialog::response</a> signal will
--   *not* be emitted until after the next call to <a>nativeDialogShow</a>.
--   
--   If the dialog is not visible this does nothing.
nativeDialogHide :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Sets a dialog modal or non-modal.
--   
--   Modal dialogs prevent interaction with other windows in the same
--   application. To keep modal dialogs on top of main application windows,
--   use <a>nativeDialogSetTransientFor</a> to make the dialog transient
--   for the parent; most window managers will then disallow lowering the
--   dialog below the parent.
nativeDialogSetModal :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> Bool -> m ()

-- | Sets the title of the <tt>GtkNativeDialog.</tt>
nativeDialogSetTitle :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> Text -> m ()

-- | Dialog windows should be set transient for the main application window
--   they were spawned from.
--   
--   This allows window managers to e.g. keep the dialog on top of the main
--   window, or center the dialog over the main window.
--   
--   Passing <a>Nothing</a> for <i><tt>parent</tt></i> unsets the current
--   transient window.
nativeDialogSetTransientFor :: (HasCallStack, MonadIO m, IsNativeDialog a, IsWindow b) => a -> Maybe b -> m ()

-- | Shows the dialog on the display.
--   
--   When the user accepts the state of the dialog the dialog will be
--   automatically hidden and the <a>NativeDialog::response</a> signal will
--   be emitted.
--   
--   Multiple calls while the dialog is visible will be ignored.
nativeDialogShow :: (HasCallStack, MonadIO m, IsNativeDialog a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNativeDialogModal :: (IsNativeDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #modal
--   </pre>
getNativeDialogModal :: (MonadIO m, IsNativeDialog o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #modal <a>:=</a> value ]
--   </pre>
setNativeDialogModal :: (MonadIO m, IsNativeDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNativeDialogTitle :: (IsNativeDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #title
--   </pre>
getNativeDialogTitle :: (MonadIO m, IsNativeDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #title <a>:=</a> value ]
--   </pre>
setNativeDialogTitle :: (MonadIO m, IsNativeDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>transient-for</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #transientFor
--   </pre>
clearNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transient-for</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNativeDialogTransientFor :: (IsNativeDialog o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #transientFor
--   </pre>
getNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o) => o -> m (Maybe Window)

-- | Set the value of the “<tt>transient-for</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #transientFor <a>:=</a> value ]
--   </pre>
setNativeDialogTransientFor :: (MonadIO m, IsNativeDialog o, IsWindow a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNativeDialogVisible :: (IsNativeDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> nativeDialog #visible
--   </pre>
getNativeDialogVisible :: (MonadIO m, IsNativeDialog o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> nativeDialog [ #visible <a>:=</a> value ]
--   </pre>
setNativeDialogVisible :: (MonadIO m, IsNativeDialog o) => o -> Bool -> m ()

-- | Emitted when the user responds to the dialog.
--   
--   When this is called the dialog has been hidden.
--   
--   If you call <a>nativeDialogHide</a> before the user responds to the
--   dialog this signal will not be emitted.
type NativeDialogResponseCallback = Int32 -> IO ()

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> nativeDialog #response callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterNativeDialogResponse :: (IsNativeDialog a, MonadIO m) => a -> ((?self :: a) => NativeDialogResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> nativeDialog #response callback
--   </pre>
onNativeDialogResponse :: (IsNativeDialog a, MonadIO m) => a -> ((?self :: a) => NativeDialogResponseCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.NativeDialog.NativeDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.NativeDialog.NativeDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.NativeDialog.NativeDialog
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.NativeDialog.NativeDialog)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.NativeDialog.NativeDialog o) => GI.Gtk.Objects.NativeDialog.IsNativeDialog o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.NativeDialog.NativeDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.NativeDialog.NativeDialog


-- | Activates a named action.
--   
--   See <a>widgetClassInstallAction</a> and <a>widgetInsertActionGroup</a>
--   for ways to associate named actions with widgets.
module GI.Gtk.Objects.NamedAction

-- | Memory-managed wrapper type.
newtype NamedAction
NamedAction :: ManagedPtr NamedAction -> NamedAction

-- | Type class for types which can be safely cast to <a>NamedAction</a>,
--   for instance with <a>toNamedAction</a>.
class (GObject o, IsDescendantOf NamedAction o) => IsNamedAction o

-- | Cast to <a>NamedAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNamedAction :: (MonadIO m, IsNamedAction o) => o -> m NamedAction

-- | Returns the name of the action that will be activated.
namedActionGetActionName :: (HasCallStack, MonadIO m, IsNamedAction a) => a -> m Text

-- | Creates an action that when activated, activates the named action on
--   the widget.
--   
--   It also passes the given arguments to it.
--   
--   See <a>widgetInsertActionGroup</a> for how to add actions to widgets.
namedActionNew :: (HasCallStack, MonadIO m) => Text -> m NamedAction

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructNamedActionActionName :: (IsNamedAction o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> namedAction #actionName
--   </pre>
getNamedActionActionName :: (MonadIO m, IsNamedAction o) => o -> m Text
instance GHC.Classes.Eq GI.Gtk.Objects.NamedAction.NamedAction
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.NamedAction.NamedAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.NamedAction.NamedAction
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.NamedAction.NamedAction)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.NamedAction.NamedAction o) => GI.Gtk.Objects.NamedAction.IsNamedAction o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.NamedAction.NamedAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.NamedAction.NamedAction


-- | Asks the user for passwords and other information required to mount a
--   volume.
--   
--   <tt>GtkMountOperation</tt> is needed when mounting volumes: It is an
--   implementation of <tt>GMountOperation</tt> that can be used with GIO
--   functions for mounting volumes such as
--   <a>fileMountEnclosingVolume</a>, <a>fileMountMountable</a>,
--   <a>volumeMount</a>, <a>mountUnmountWithOperation</a> and others.
--   
--   When necessary, <tt>GtkMountOperation</tt> shows dialogs to let the
--   user enter passwords, ask questions or show processes blocking
--   unmount.
module GI.Gtk.Objects.MountOperation

-- | Memory-managed wrapper type.
newtype MountOperation
MountOperation :: ManagedPtr MountOperation -> MountOperation

-- | Type class for types which can be safely cast to
--   <a>MountOperation</a>, for instance with <a>toMountOperation</a>.
class (GObject o, IsDescendantOf MountOperation o) => IsMountOperation o

-- | Cast to <a>MountOperation</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMountOperation :: (MonadIO m, IsMountOperation o) => o -> m MountOperation

-- | Gets the display on which windows of the <tt>GtkMountOperation</tt>
--   will be shown.
mountOperationGetDisplay :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Display

-- | Gets the transient parent used by the <tt>GtkMountOperation</tt>.
mountOperationGetParent :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m (Maybe Window)

-- | Returns whether the <tt>GtkMountOperation</tt> is currently displaying
--   a window.
mountOperationIsShowing :: (HasCallStack, MonadIO m, IsMountOperation a) => a -> m Bool

-- | Creates a new <tt>GtkMountOperation</tt>.
mountOperationNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> m MountOperation

-- | Sets the display to show windows of the <tt>GtkMountOperation</tt> on.
mountOperationSetDisplay :: (HasCallStack, MonadIO m, IsMountOperation a, IsDisplay b) => a -> b -> m ()

-- | Sets the transient parent for windows shown by the
--   <tt>GtkMountOperation</tt>.
mountOperationSetParent :: (HasCallStack, MonadIO m, IsMountOperation a, IsWindow b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>display</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMountOperationDisplay :: (IsMountOperation o, MonadIO m, IsDisplay a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mountOperation #display
--   </pre>
getMountOperationDisplay :: (MonadIO m, IsMountOperation o) => o -> m Display

-- | Set the value of the “<tt>display</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mountOperation [ #display <a>:=</a> value ]
--   </pre>
setMountOperationDisplay :: (MonadIO m, IsMountOperation o, IsDisplay a) => o -> a -> m ()

-- | Get the value of the “<tt>is-showing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mountOperation #isShowing
--   </pre>
getMountOperationIsShowing :: (MonadIO m, IsMountOperation o) => o -> m Bool

-- | Set the value of the “<tt>parent</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #parent
--   </pre>
clearMountOperationParent :: (MonadIO m, IsMountOperation o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>parent</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMountOperationParent :: (IsMountOperation o, MonadIO m, IsWindow a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mountOperation #parent
--   </pre>
getMountOperationParent :: (MonadIO m, IsMountOperation o) => o -> m (Maybe Window)

-- | Set the value of the “<tt>parent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mountOperation [ #parent <a>:=</a> value ]
--   </pre>
setMountOperationParent :: (MonadIO m, IsMountOperation o, IsWindow a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.MountOperation.MountOperation
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MountOperation.MountOperation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MountOperation.MountOperation
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MountOperation.MountOperation)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MountOperation.MountOperation o) => GI.Gtk.Objects.MountOperation.IsMountOperation o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MountOperation.MountOperation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MountOperation.MountOperation


-- | Activates a widget with a mnemonic.
--   
--   This means that <a>widgetMnemonicActivate</a> is called.
module GI.Gtk.Objects.MnemonicAction

-- | Memory-managed wrapper type.
newtype MnemonicAction
MnemonicAction :: ManagedPtr MnemonicAction -> MnemonicAction

-- | Type class for types which can be safely cast to
--   <a>MnemonicAction</a>, for instance with <a>toMnemonicAction</a>.
class (GObject o, IsDescendantOf MnemonicAction o) => IsMnemonicAction o

-- | Cast to <a>MnemonicAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMnemonicAction :: (MonadIO m, IsMnemonicAction o) => o -> m MnemonicAction

-- | Gets the mnemonic action.
--   
--   This is an action that calls <a>widgetMnemonicActivate</a> on the
--   given widget upon activation.
mnemonicActionGet :: (HasCallStack, MonadIO m) => m MnemonicAction
instance GHC.Classes.Eq GI.Gtk.Objects.MnemonicAction.MnemonicAction
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MnemonicAction.MnemonicAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MnemonicAction.MnemonicAction
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MnemonicAction.MnemonicAction)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MnemonicAction.MnemonicAction o) => GI.Gtk.Objects.MnemonicAction.IsMnemonicAction o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MnemonicAction.MnemonicAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MnemonicAction.MnemonicAction


-- | <tt>GtkMessageDialog</tt> presents a dialog with some message text.
--   
--   &lt;picture&gt; &lt;source srcset="messagedialog-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkMessageDialog" src="messagedialog.png"&gt; &lt;/picture&gt;
--   
--   It’s simply a convenience widget; you could construct the equivalent
--   of <tt>GtkMessageDialog</tt> from <tt>GtkDialog</tt> without too much
--   effort, but <tt>GtkMessageDialog</tt> saves typing.
--   
--   The easiest way to do a modal message dialog is to use the
--   <a>DialogFlagsModal</a> flag, which will call <a>windowSetModal</a>
--   internally. The dialog will prevent interaction with the parent window
--   until it's hidden or destroyed. You can use the
--   <a>Dialog::response</a> signal to know when the user dismissed the
--   dialog.
--   
--   An example for using a modal dialog:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL;
--   dialog = gtk_message_dialog_new (parent_window,
--                                    flags,
--                                    GTK_MESSAGE_ERROR,
--                                    GTK_BUTTONS_CLOSE,
--                                    "Error reading “%s”: %s",
--                                    filename,
--                                    g_strerror (errno));
--   // Destroy the dialog when the user responds to it
--   // (e.g. clicks a button)
--   
--   g_signal_connect (dialog, "response",
--                     G_CALLBACK (gtk_window_destroy),
--                     NULL);
--   </pre>
--   
--   You might do a non-modal <tt>GtkMessageDialog</tt> simply by omitting
--   the <a>DialogFlagsModal</a> flag:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
--   dialog = gtk_message_dialog_new (parent_window,
--                                    flags,
--                                    GTK_MESSAGE_ERROR,
--                                    GTK_BUTTONS_CLOSE,
--                                    "Error reading “%s”: %s",
--                                    filename,
--                                    g_strerror (errno));
--   
--   // Destroy the dialog when the user responds to it
--   // (e.g. clicks a button)
--   g_signal_connect (dialog, "response",
--                     G_CALLBACK (gtk_window_destroy),
--                     NULL);
--   </pre>
--   
--   <h1>GtkMessageDialog as GtkBuildable</h1>
--   
--   The <tt>GtkMessageDialog</tt> implementation of the
--   <tt>GtkBuildable</tt> interface exposes the message area as an
--   internal child with the name “message_area”.
module GI.Gtk.Objects.MessageDialog

-- | Memory-managed wrapper type.
newtype MessageDialog
MessageDialog :: ManagedPtr MessageDialog -> MessageDialog

-- | Type class for types which can be safely cast to <a>MessageDialog</a>,
--   for instance with <a>toMessageDialog</a>.
class (GObject o, IsDescendantOf MessageDialog o) => IsMessageDialog o

-- | Cast to <a>MessageDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMessageDialog :: (MonadIO m, IsMessageDialog o) => o -> m MessageDialog

-- | Returns the message area of the dialog.
--   
--   This is the box where the dialog’s primary and secondary labels are
--   packed. You can add your own extra content to that box and it will
--   appear below those labels. See <a>dialogGetContentArea</a> for the
--   corresponding function in the parent <a>Dialog</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>AlertDialog</a> instead</i>
messageDialogGetMessageArea :: (HasCallStack, MonadIO m, IsMessageDialog a) => a -> m Widget

-- | Sets the text of the message dialog.

-- | <i>Deprecated: (Since version 4.10)Use <a>AlertDialog</a> instead</i>
messageDialogSetMarkup :: (HasCallStack, MonadIO m, IsMessageDialog a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buttons</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMessageDialogButtons :: (IsMessageDialog o, MonadIO m) => ButtonsType -> m (GValueConstruct o)

-- | Get the value of the “<tt>message-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #messageArea
--   </pre>
getMessageDialogMessageArea :: (MonadIO m, IsMessageDialog o) => o -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>message-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMessageDialogMessageType :: (IsMessageDialog o, MonadIO m) => MessageType -> m (GValueConstruct o)

-- | Get the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #messageType
--   </pre>
getMessageDialogMessageType :: (MonadIO m, IsMessageDialog o) => o -> m MessageType

-- | Set the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #messageType <a>:=</a> value ]
--   </pre>
setMessageDialogMessageType :: (MonadIO m, IsMessageDialog o) => o -> MessageType -> m ()

-- | Set the value of the “<tt>secondary-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryText
--   </pre>
clearMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMessageDialogSecondaryText :: (IsMessageDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #secondaryText
--   </pre>
getMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #secondaryText <a>:=</a> value ]
--   </pre>
setMessageDialogSecondaryText :: (MonadIO m, IsMessageDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-use-markup</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructMessageDialogSecondaryUseMarkup :: (IsMessageDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #secondaryUseMarkup
--   </pre>
getMessageDialogSecondaryUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool

-- | Set the value of the “<tt>secondary-use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #secondaryUseMarkup <a>:=</a> value ]
--   </pre>
setMessageDialogSecondaryUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMessageDialogText :: (IsMessageDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #text
--   </pre>
getMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #text <a>:=</a> value ]
--   </pre>
setMessageDialogText :: (MonadIO m, IsMessageDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-markup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMessageDialogUseMarkup :: (IsMessageDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> messageDialog #useMarkup
--   </pre>
getMessageDialogUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool

-- | Set the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> messageDialog [ #useMarkup <a>:=</a> value ]
--   </pre>
setMessageDialogUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.MessageDialog.MessageDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MessageDialog.MessageDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MessageDialog.MessageDialog
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MessageDialog.MessageDialog)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MessageDialog.MessageDialog o) => GI.Gtk.Objects.MessageDialog.IsMessageDialog o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MessageDialog.MessageDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MessageDialog.MessageDialog


-- | Displays a popup when clicked.
--   
--   &lt;picture&gt; &lt;source srcset="menu-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkMenuButton" src="menu-button.png"&gt; &lt;/picture&gt;
--   
--   This popup can be provided either as a <tt>GtkPopover</tt> or as an
--   abstract <tt>GMenuModel</tt>.
--   
--   The <tt>GtkMenuButton</tt> widget can show either an icon (set with
--   the <a>MenuButton:iconName</a> property) or a label (set with the
--   <a>MenuButton:label</a> property). If neither is explicitly set, a
--   <a>Image</a> is automatically created, using an arrow image oriented
--   according to <a>MenuButton:direction</a> or the generic
--   “open-menu-symbolic” icon if the direction is not set.
--   
--   The positioning of the popup is determined by the
--   <a>MenuButton:direction</a> property of the menu button.
--   
--   For menus, the <a>Widget:halign</a> and <a>Widget:valign</a>
--   properties of the menu are also taken into account. For example, when
--   the direction is <a>ArrowTypeDown</a> and the horizontal alignment is
--   <a>AlignStart</a>, the menu will be positioned below the button, with
--   the starting edge (depending on the text direction) of the menu
--   aligned with the starting edge of the button. If there is not enough
--   space below the button, the menu is popped up above the button
--   instead. If the alignment would move part of the menu offscreen, it is
--   “pushed in”.
--   
--   | | start | center | end | | - | --- | --- | --- | | <b>down</b> | | |
--   | | <b>up</b> | | | | | <b>left</b> | | | | | <b>right</b> | | | |
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   menubutton
--   ╰── button.toggle
--       ╰── &lt;content&gt;
--            ╰── [arrow]
--   </pre>
--   
--   <tt>GtkMenuButton</tt> has a single CSS node with name
--   <tt>menubutton</tt> which contains a <tt>button</tt> node with a
--   <tt>.toggle</tt> style class.
--   
--   If the button contains an icon, it will have the
--   <tt>.image-button</tt> style class, if it contains text, it will have
--   <tt>.text-button</tt> style class. If an arrow is visible in addition
--   to an icon, text or a custom child, it will also have
--   <tt>.arrow-button</tt> style class.
--   
--   Inside the toggle button content, there is an <tt>arrow</tt> node for
--   the indicator, which will carry one of the <tt>.none</tt>,
--   <tt>.up</tt>, <tt>.down</tt>, <tt>.left</tt> or <tt>.right</tt> style
--   classes to indicate the direction that the menu will appear in. The
--   CSS is expected to provide a suitable image for each of these cases
--   using the <tt>-gtk-icon-source</tt> property.
--   
--   Optionally, the <tt>menubutton</tt> node can carry the
--   <tt>.circular</tt> style class to request a round appearance.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkMenuButton</tt> uses the <a>AccessibleRoleButton</a> role.
module GI.Gtk.Objects.MenuButton

-- | Memory-managed wrapper type.
newtype MenuButton
MenuButton :: ManagedPtr MenuButton -> MenuButton

-- | Type class for types which can be safely cast to <a>MenuButton</a>,
--   for instance with <a>toMenuButton</a>.
class (GObject o, IsDescendantOf MenuButton o) => IsMenuButton o

-- | Cast to <a>MenuButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMenuButton :: (MonadIO m, IsMenuButton o) => o -> m MenuButton

-- | Returns whether the menu button is active.
--   
--   <i>Since: 4.10</i>
menuButtonGetActive :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Gets whether to show a dropdown arrow even when using an icon or a
--   custom child.
--   
--   <i>Since: 4.4</i>
menuButtonGetAlwaysShowArrow :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Retrieves whether the button can be smaller than the natural size of
--   its contents.
--   
--   <i>Since: 4.12</i>
menuButtonGetCanShrink :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Gets the child widget of <i><tt>menuButton</tt></i>.
--   
--   <i>Since: 4.6</i>
menuButtonGetChild :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Widget)

-- | Returns the direction the popup will be pointing at when popped up.
menuButtonGetDirection :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m ArrowType

-- | Returns whether the button has a frame.
menuButtonGetHasFrame :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Gets the name of the icon shown in the button.
menuButtonGetIconName :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Text)

-- | Gets the label shown in the button
menuButtonGetLabel :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Text)

-- | Returns the <tt>GMenuModel</tt> used to generate the popup.
menuButtonGetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe MenuModel)

-- | Returns the <tt>GtkPopover</tt> that pops out of the button.
--   
--   If the button is not using a <tt>GtkPopover</tt>, this function
--   returns <a>Nothing</a>.
menuButtonGetPopover :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m (Maybe Popover)

-- | Returns whether the menu button acts as a primary menu.
--   
--   <i>Since: 4.4</i>
menuButtonGetPrimary :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Returns whether an embedded underline in the text indicates a
--   mnemonic.
menuButtonGetUseUnderline :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m Bool

-- | Creates a new <tt>GtkMenuButton</tt> widget with downwards-pointing
--   arrow as the only child.
--   
--   You can replace the child widget with another <tt>GtkWidget</tt>
--   should you wish to.
menuButtonNew :: (HasCallStack, MonadIO m) => m MenuButton

-- | Dismiss the menu.
menuButtonPopdown :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m ()

-- | Pop up the menu.
menuButtonPopup :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> m ()

-- | Sets whether the menu button is active.
--   
--   <i>Since: 4.10</i>
menuButtonSetActive :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | Sets whether to show a dropdown arrow even when using an icon or a
--   custom child.
--   
--   <i>Since: 4.4</i>
menuButtonSetAlwaysShowArrow :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | Sets whether the button size can be smaller than the natural size of
--   its contents.
--   
--   For text buttons, setting <i><tt>canShrink</tt></i> to true will
--   ellipsize the label.
--   
--   For icon buttons, this function has no effect.
--   
--   <i>Since: 4.12</i>
menuButtonSetCanShrink :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | Sets the child widget of <i><tt>menuButton</tt></i>.
--   
--   Setting a child resets <a>MenuButton:label</a> and
--   <a>MenuButton:iconName</a>.
--   
--   If <a>MenuButton:alwaysShowArrow</a> is set to <tt>TRUE</tt> and
--   <a>MenuButton:direction</a> is not <tt>GTK_ARROW_NONE</tt>, a dropdown
--   arrow will be shown next to the child.
--   
--   <i>Since: 4.6</i>
menuButtonSetChild :: (HasCallStack, MonadIO m, IsMenuButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets <i><tt>func</tt></i> to be called when a popup is about to be
--   shown.
--   
--   <i><tt>func</tt></i> should use one of
--   
--   <ul>
--   <li><a>menuButtonSetPopover</a></li>
--   <li><a>menuButtonSetMenuModel</a></li>
--   </ul>
--   
--   to set a popup for <i><tt>menuButton</tt></i>. If <i><tt>func</tt></i>
--   is non-<a>Nothing</a>, <i><tt>menuButton</tt></i> will always be
--   sensitive.
--   
--   Using this function will not reset the menu widget attached to
--   <i><tt>menuButton</tt></i>. Instead, this can be done manually in
--   <i><tt>func</tt></i>.
menuButtonSetCreatePopupFunc :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Maybe MenuButtonCreatePopupFunc -> m ()

-- | Sets the direction in which the popup will be popped up.
--   
--   If the button is automatically populated with an arrow icon, its
--   direction will be changed to match.
--   
--   If the does not fit in the available space in the given direction, GTK
--   will its best to keep it inside the screen and fully visible.
--   
--   If you pass <a>ArrowTypeNone</a> for a <i><tt>direction</tt></i>, the
--   popup will behave as if you passed <a>ArrowTypeDown</a> (although you
--   won’t see any arrows).
menuButtonSetDirection :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> ArrowType -> m ()

-- | Sets the style of the button.
menuButtonSetHasFrame :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | Sets the name of an icon to show inside the menu button.
--   
--   Setting icon name resets <a>MenuButton:label</a> and
--   <a>MenuButton:child</a>.
--   
--   If <a>MenuButton:alwaysShowArrow</a> is set to <tt>TRUE</tt> and
--   <a>MenuButton:direction</a> is not <tt>GTK_ARROW_NONE</tt>, a dropdown
--   arrow will be shown next to the icon.
menuButtonSetIconName :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Text -> m ()

-- | Sets the label to show inside the menu button.
--   
--   Setting a label resets <a>MenuButton:iconName</a> and
--   <a>MenuButton:child</a>.
--   
--   If <a>MenuButton:direction</a> is not <tt>GTK_ARROW_NONE</tt>, a
--   dropdown arrow will be shown next to the label.
menuButtonSetLabel :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Text -> m ()

-- | Sets the <tt>GMenuModel</tt> from which the popup will be constructed.
--   
--   If <i><tt>menuModel</tt></i> is <a>Nothing</a>, the button is
--   disabled.
--   
--   A <a>Popover</a> will be created from the menu model with
--   <a>popoverMenuNewFromModel</a>. Actions will be connected as
--   documented for this function.
--   
--   If <a>MenuButton:popover</a> is already set, it will be dissociated
--   from the <i><tt>menuButton</tt></i>, and the property is set to
--   <a>Nothing</a>.
menuButtonSetMenuModel :: (HasCallStack, MonadIO m, IsMenuButton a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkPopover</tt> that will be popped up when the
--   <i><tt>menuButton</tt></i> is clicked.
--   
--   If <i><tt>popover</tt></i> is <a>Nothing</a>, the button is disabled.
--   
--   If <a>MenuButton:menuModel</a> is set, the menu model is dissociated
--   from the <i><tt>menuButton</tt></i>, and the property is set to
--   <a>Nothing</a>.
menuButtonSetPopover :: (HasCallStack, MonadIO m, IsMenuButton a, IsPopover b) => a -> Maybe b -> m ()

-- | Sets whether menu button acts as a primary menu.
--   
--   Primary menus can be opened with the &lt;kbd&gt;F10&lt;/kbd&gt; key.
--   
--   <i>Since: 4.4</i>
menuButtonSetPrimary :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | If true, an underline in the text indicates a mnemonic.
menuButtonSetUseUnderline :: (HasCallStack, MonadIO m, IsMenuButton a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuButtonActive :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #active
--   </pre>
getMenuButtonActive :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #active <a>:=</a> value ]
--   </pre>
setMenuButtonActive :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>always-show-arrow</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructMenuButtonAlwaysShowArrow :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>always-show-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #alwaysShowArrow
--   </pre>
getMenuButtonAlwaysShowArrow :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “<tt>always-show-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #alwaysShowArrow <a>:=</a> value ]
--   </pre>
setMenuButtonAlwaysShowArrow :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-shrink</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuButtonCanShrink :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-shrink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #canShrink
--   </pre>
getMenuButtonCanShrink :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “<tt>can-shrink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #canShrink <a>:=</a> value ]
--   </pre>
setMenuButtonCanShrink :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearMenuButtonChild :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuButtonChild :: (IsMenuButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #child
--   </pre>
getMenuButtonChild :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #child <a>:=</a> value ]
--   </pre>
setMenuButtonChild :: (MonadIO m, IsMenuButton o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>direction</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuButtonDirection :: (IsMenuButton o, MonadIO m) => ArrowType -> m (GValueConstruct o)

-- | Get the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #direction
--   </pre>
getMenuButtonDirection :: (MonadIO m, IsMenuButton o) => o -> m ArrowType

-- | Set the value of the “<tt>direction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #direction <a>:=</a> value ]
--   </pre>
setMenuButtonDirection :: (MonadIO m, IsMenuButton o) => o -> ArrowType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuButtonHasFrame :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #hasFrame
--   </pre>
getMenuButtonHasFrame :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #hasFrame <a>:=</a> value ]
--   </pre>
setMenuButtonHasFrame :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuButtonIconName :: (IsMenuButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #iconName
--   </pre>
getMenuButtonIconName :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #iconName <a>:=</a> value ]
--   </pre>
setMenuButtonIconName :: (MonadIO m, IsMenuButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuButtonLabel :: (IsMenuButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #label
--   </pre>
getMenuButtonLabel :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #label <a>:=</a> value ]
--   </pre>
setMenuButtonLabel :: (MonadIO m, IsMenuButton o) => o -> Text -> m ()

-- | Set the value of the “<tt>menu-model</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuModel
--   </pre>
clearMenuButtonMenuModel :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-model</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructMenuButtonMenuModel :: (IsMenuButton o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #menuModel
--   </pre>
getMenuButtonMenuModel :: (MonadIO m, IsMenuButton o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>menu-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #menuModel <a>:=</a> value ]
--   </pre>
setMenuButtonMenuModel :: (MonadIO m, IsMenuButton o, IsMenuModel a) => o -> a -> m ()

-- | Set the value of the “<tt>popover</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #popover
--   </pre>
clearMenuButtonPopover :: (MonadIO m, IsMenuButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popover</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuButtonPopover :: (IsMenuButton o, MonadIO m, IsPopover a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #popover
--   </pre>
getMenuButtonPopover :: (MonadIO m, IsMenuButton o) => o -> m (Maybe Popover)

-- | Set the value of the “<tt>popover</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #popover <a>:=</a> value ]
--   </pre>
setMenuButtonPopover :: (MonadIO m, IsMenuButton o, IsPopover a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMenuButtonPrimary :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #primary
--   </pre>
getMenuButtonPrimary :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “<tt>primary</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #primary <a>:=</a> value ]
--   </pre>
setMenuButtonPrimary :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMenuButtonUseUnderline :: (IsMenuButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> menuButton #useUnderline
--   </pre>
getMenuButtonUseUnderline :: (MonadIO m, IsMenuButton o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> menuButton [ #useUnderline <a>:=</a> value ]
--   </pre>
setMenuButtonUseUnderline :: (MonadIO m, IsMenuButton o) => o -> Bool -> m ()

-- | Emitted to when the menu button is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkMenuButton</tt> is an action
--   signal and emitting it causes the button to pop up its menu.
--   
--   <i>Since: 4.4</i>
type MenuButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> menuButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterMenuButtonActivate :: (IsMenuButton a, MonadIO m) => a -> ((?self :: a) => MenuButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> menuButton #activate callback
--   </pre>
onMenuButtonActivate :: (IsMenuButton a, MonadIO m) => a -> ((?self :: a) => MenuButtonActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.MenuButton.MenuButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MenuButton.MenuButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MenuButton.MenuButton
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MenuButton.MenuButton)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MenuButton.MenuButton o) => GI.Gtk.Objects.MenuButton.IsMenuButton o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MenuButton.MenuButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MenuButton.MenuButton


-- | Shows controls for video playback.
--   
--   &lt;picture&gt; &lt;source srcset="media-controls-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkMediaControls" src="media-controls.png"&gt; &lt;/picture&gt;
--   
--   Usually, <tt>GtkMediaControls</tt> is used as part of <a>Video</a>.
module GI.Gtk.Objects.MediaControls

-- | Memory-managed wrapper type.
newtype MediaControls
MediaControls :: ManagedPtr MediaControls -> MediaControls

-- | Type class for types which can be safely cast to <a>MediaControls</a>,
--   for instance with <a>toMediaControls</a>.
class (GObject o, IsDescendantOf MediaControls o) => IsMediaControls o

-- | Cast to <a>MediaControls</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMediaControls :: (MonadIO m, IsMediaControls o) => o -> m MediaControls

-- | Gets the media stream managed by <i><tt>controls</tt></i> or
--   <a>Nothing</a> if none.
mediaControlsGetMediaStream :: (HasCallStack, MonadIO m, IsMediaControls a) => a -> m (Maybe MediaStream)

-- | Creates a new <tt>GtkMediaControls</tt> managing the
--   <i><tt>stream</tt></i> passed to it.
mediaControlsNew :: (HasCallStack, MonadIO m, IsMediaStream a) => Maybe a -> m MediaControls

-- | Sets the stream that is controlled by <i><tt>controls</tt></i>.
mediaControlsSetMediaStream :: (HasCallStack, MonadIO m, IsMediaControls a, IsMediaStream b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>media-stream</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #mediaStream
--   </pre>
clearMediaControlsMediaStream :: (MonadIO m, IsMediaControls o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>media-stream</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructMediaControlsMediaStream :: (IsMediaControls o, MonadIO m, IsMediaStream a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>media-stream</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mediaControls #mediaStream
--   </pre>
getMediaControlsMediaStream :: (MonadIO m, IsMediaControls o) => o -> m (Maybe MediaStream)

-- | Set the value of the “<tt>media-stream</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mediaControls [ #mediaStream <a>:=</a> value ]
--   </pre>
setMediaControlsMediaStream :: (MonadIO m, IsMediaControls o, IsMediaStream a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.MediaControls.MediaControls
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MediaControls.MediaControls
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MediaControls.MediaControls
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MediaControls.MediaControls)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MediaControls.MediaControls o) => GI.Gtk.Objects.MediaControls.IsMediaControls o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MediaControls.MediaControls
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MediaControls.MediaControls


-- | A list model that maps the items in another model to different items.
--   
--   <tt>GtkMapListModel</tt> uses a
--   [callback<i><tt>gtk</tt></i>.MapListModelMapFunc].
--   
--   Example: Create a list of <tt>GtkEventControllers</tt>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static gpointer
--   map_to_controllers (gpointer widget,
--                       gpointer data)
--   {
--     gpointer result = gtk_widget_observe_controllers (widget);
--     g_object_unref (widget);
--     return result;
--   }
--   
--   widgets = gtk_widget_observe_children (widget);
--   
--   controllers = gtk_map_list_model_new (widgets,
--                                         map_to_controllers,
--                                         NULL, NULL);
--   
--   model = gtk_flatten_list_model_new (GTK_TYPE_EVENT_CONTROLLER,
--                                       controllers);
--   </pre>
--   
--   <tt>GtkMapListModel</tt> will attempt to discard the mapped objects as
--   soon as they are no longer needed and recreate them if necessary.
--   
--   <tt>GtkMapListModel</tt> passes through sections from the underlying
--   model.
module GI.Gtk.Objects.MapListModel

-- | Memory-managed wrapper type.
newtype MapListModel
MapListModel :: ManagedPtr MapListModel -> MapListModel

-- | Type class for types which can be safely cast to <a>MapListModel</a>,
--   for instance with <a>toMapListModel</a>.
class (GObject o, IsDescendantOf MapListModel o) => IsMapListModel o

-- | Cast to <a>MapListModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMapListModel :: (MonadIO m, IsMapListModel o) => o -> m MapListModel

-- | Gets the model that is currently being mapped or <a>Nothing</a> if
--   none.
mapListModelGetModel :: (HasCallStack, MonadIO m, IsMapListModel a) => a -> m (Maybe ListModel)

-- | Checks if a map function is currently set on <i><tt>self</tt></i>.
mapListModelHasMap :: (HasCallStack, MonadIO m, IsMapListModel a) => a -> m Bool

-- | Creates a new <tt>GtkMapListModel</tt> for the given arguments.
mapListModelNew :: (HasCallStack, MonadIO m, IsListModel a) => Maybe a -> Maybe MapListModelMapFunc -> m MapListModel

-- | Sets the function used to map items.
--   
--   The function will be called whenever an item needs to be mapped and
--   must return the item to use for the given input item.
--   
--   Note that <tt>GtkMapListModel</tt> may call this function multiple
--   times on the same item, because it may delete items it doesn't need
--   anymore.
--   
--   GTK makes no effort to ensure that <i><tt>mapFunc</tt></i> conforms to
--   the item type of <i><tt>self</tt></i>. It assumes that the caller
--   knows what they are doing and the map function returns items of the
--   appropriate type.
mapListModelSetMapFunc :: (HasCallStack, MonadIO m, IsMapListModel a) => a -> Maybe MapListModelMapFunc -> m ()

-- | Sets the model to be mapped.
--   
--   GTK makes no effort to ensure that <i><tt>model</tt></i> conforms to
--   the item type expected by the map function. It assumes that the caller
--   knows what they are doing and have set up an appropriate map function.
mapListModelSetModel :: (HasCallStack, MonadIO m, IsMapListModel a, IsListModel b) => a -> Maybe b -> m ()

-- | Get the value of the “<tt>has-map</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mapListModel #hasMap
--   </pre>
getMapListModelHasMap :: (MonadIO m, IsMapListModel o) => o -> m Bool

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mapListModel #itemType
--   </pre>
getMapListModelItemType :: (MonadIO m, IsMapListModel o) => o -> m GType

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearMapListModelModel :: (MonadIO m, IsMapListModel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructMapListModelModel :: (IsMapListModel o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mapListModel #model
--   </pre>
getMapListModelModel :: (MonadIO m, IsMapListModel o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mapListModel [ #model <a>:=</a> value ]
--   </pre>
setMapListModelModel :: (MonadIO m, IsMapListModel o, IsListModel a) => o -> a -> m ()

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mapListModel #nItems
--   </pre>
getMapListModelNItems :: (MonadIO m, IsMapListModel o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.MapListModel.MapListModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.MapListModel.MapListModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.MapListModel.MapListModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.MapListModel.MapListModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.MapListModel.MapListModel o) => GI.Gtk.Objects.MapListModel.IsMapListModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.MapListModel.MapListModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.MapListModel.MapListModel


-- | <tt>GtkLockButton</tt> is a widget to obtain and revoke authorizations
--   needed to operate the controls.
--   
--   &lt;picture&gt; &lt;source srcset="lockbutton-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkLockButton" src="lockbutton.png"&gt; &lt;/picture&gt;
--   
--   It is typically used in preference dialogs or control panels.
--   
--   The required authorization is represented by a <tt>GPermission</tt>
--   object. Concrete implementations of <tt>GPermission</tt> may use
--   PolicyKit or some other authorization framework. To obtain a
--   PolicyKit-based <tt>GPermission</tt>, use
--   <tt>polkit_permission_new()</tt>.
--   
--   If the user is not currently allowed to perform the action, but can
--   obtain the permission, the widget looks like this:
--   
--   &lt;picture&gt; &lt;source srcset="lockbutton-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An locked
--   GtkLockButton" src="lockbutton.png"&gt; &lt;/picture&gt;
--   
--   and the user can click the button to request the permission. Depending
--   on the platform, this may pop up an authentication dialog or ask the
--   user to authenticate in some other way. Once the user has obtained the
--   permission, the widget changes to this:
--   
--   &lt;picture&gt; &lt;source srcset="lockbutton-unlocked-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An unlocked
--   GtkLockButton" src="lockbutton-unlocked.png"&gt; &lt;/picture&gt;
--   
--   and the permission can be dropped again by clicking the button. If the
--   user is not able to obtain the permission at all, the widget looks
--   like this:
--   
--   &lt;picture&gt; &lt;source srcset="lockbutton-sorry-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An unobtainable
--   GtkLockButton" src="lockbutton-sorry.png"&gt; &lt;/picture&gt;
--   
--   If the user has the permission and cannot drop it, the button is
--   hidden.
--   
--   The text (and tooltips) that are shown in the various cases can be
--   adjusted with the <a>LockButton:textLock</a>,
--   <a>LockButton:textUnlock</a>, <a>LockButton:tooltipLock</a>,
--   <a>LockButton:tooltipUnlock</a> and
--   <a>LockButton:tooltipNotAuthorized</a> properties.
module GI.Gtk.Objects.LockButton

-- | Memory-managed wrapper type.
newtype LockButton
LockButton :: ManagedPtr LockButton -> LockButton

-- | Type class for types which can be safely cast to <a>LockButton</a>,
--   for instance with <a>toLockButton</a>.
class (GObject o, IsDescendantOf LockButton o) => IsLockButton o

-- | Cast to <a>LockButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toLockButton :: (MonadIO m, IsLockButton o) => o -> m LockButton

-- | Obtains the <tt>GPermission</tt> object that controls
--   <i><tt>button</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
lockButtonGetPermission :: (HasCallStack, MonadIO m, IsLockButton a) => a -> m (Maybe Permission)

-- | Creates a new lock button which reflects the
--   <i><tt>permission</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
lockButtonNew :: (HasCallStack, MonadIO m, IsPermission a) => Maybe a -> m LockButton

-- | Sets the <tt>GPermission</tt> object that controls
--   <i><tt>button</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
lockButtonSetPermission :: (HasCallStack, MonadIO m, IsLockButton a, IsPermission b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>permission</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #permission
--   </pre>
clearLockButtonPermission :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>permission</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLockButtonPermission :: (IsLockButton o, MonadIO m, IsPermission a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>permission</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #permission
--   </pre>
getLockButtonPermission :: (MonadIO m, IsLockButton o) => o -> m (Maybe Permission)

-- | Set the value of the “<tt>permission</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #permission <a>:=</a> value ]
--   </pre>
setLockButtonPermission :: (MonadIO m, IsLockButton o, IsPermission a) => o -> a -> m ()

-- | Set the value of the “<tt>text-lock</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #textLock
--   </pre>
clearLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-lock</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLockButtonTextLock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #textLock
--   </pre>
getLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #textLock <a>:=</a> value ]
--   </pre>
setLockButtonTextLock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Set the value of the “<tt>text-unlock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #textUnlock
--   </pre>
clearLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-unlock</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLockButtonTextUnlock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #textUnlock
--   </pre>
getLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #textUnlock <a>:=</a> value ]
--   </pre>
setLockButtonTextUnlock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Set the value of the “<tt>tooltip-lock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipLock
--   </pre>
clearLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-lock</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLockButtonTooltipLock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #tooltipLock
--   </pre>
getLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-lock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #tooltipLock <a>:=</a> value ]
--   </pre>
setLockButtonTooltipLock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Set the value of the “<tt>tooltip-not-authorized</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipNotAuthorized
--   </pre>
clearLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-not-authorized</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructLockButtonTooltipNotAuthorized :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-not-authorized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #tooltipNotAuthorized
--   </pre>
getLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-not-authorized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #tooltipNotAuthorized <a>:=</a> value ]
--   </pre>
setLockButtonTooltipNotAuthorized :: (MonadIO m, IsLockButton o) => o -> Text -> m ()

-- | Set the value of the “<tt>tooltip-unlock</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #tooltipUnlock
--   </pre>
clearLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-unlock</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLockButtonTooltipUnlock :: (IsLockButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> lockButton #tooltipUnlock
--   </pre>
getLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>tooltip-unlock</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> lockButton [ #tooltipUnlock <a>:=</a> value ]
--   </pre>
setLockButtonTooltipUnlock :: (MonadIO m, IsLockButton o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.LockButton.LockButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.LockButton.LockButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.LockButton.LockButton
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.LockButton.LockButton)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.LockButton.LockButton o) => GI.Gtk.Objects.LockButton.IsLockButton o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.LockButton.LockButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.LockButton.LockButton


-- | Presents a large dynamic list of items.
--   
--   <tt>GtkListView</tt> uses its factory to generate one row widget for
--   each visible item and shows them in a linear display, either
--   vertically or horizontally.
--   
--   The <a>ListView:showSeparators</a> property offers a simple way to
--   display separators between the rows.
--   
--   <tt>GtkListView</tt> allows the user to select items according to the
--   selection characteristics of the model. For models that allow multiple
--   selected items, it is possible to turn on _rubberband selection_,
--   using <a>ListView:enableRubberband</a>.
--   
--   If you need multiple columns with headers, see <a>ColumnView</a>.
--   
--   To learn more about the list widget framework, see the
--   <a>overview</a>.
--   
--   An example of using <tt>GtkListView</tt>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   setup_listitem_cb (GtkListItemFactory *factory,
--                      GtkListItem        *list_item)
--   {
--     GtkWidget *image;
--   
--     image = gtk_image_new ();
--     gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
--     gtk_list_item_set_child (list_item, image);
--   }
--   
--   static void
--   bind_listitem_cb (GtkListItemFactory *factory,
--                     GtkListItem        *list_item)
--   {
--     GtkWidget *image;
--     GAppInfo *app_info;
--   
--     image = gtk_list_item_get_child (list_item);
--     app_info = gtk_list_item_get_item (list_item);
--     gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
--   }
--   
--   static void
--   activate_cb (GtkListView  *list,
--                guint         position,
--                gpointer      unused)
--   {
--     GAppInfo *app_info;
--   
--     app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
--     g_app_info_launch (app_info, NULL, NULL, NULL);
--     g_object_unref (app_info);
--   }
--   
--   ...
--   
--     model = create_application_list ();
--   
--     factory = gtk_signal_list_item_factory_new ();
--     g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
--     g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
--   
--     list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
--   
--     g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);
--   
--     gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
--   </pre>
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkListView</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>list.activate-item</tt> activates the item at given position
--   by emitting the <a>ListView::activate</a> signal.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   listview[.separators][.rich-list][.navigation-sidebar][.data-table]
--   ├── row[.activatable]
--   │
--   ├── row[.activatable]
--   │
--   ┊
--   ╰── [rubberband]
--   </pre>
--   
--   <tt>GtkListView</tt> uses a single CSS node named <tt>listview</tt>.
--   It may carry the <tt>.separators</tt> style class, when
--   <a>ListView:showSeparators</a> property is set. Each child widget uses
--   a single CSS node named <tt>row</tt>. If the
--   <a>ListItem:activatable</a> property is set, the corresponding row
--   will have the <tt>.activatable</tt> style class. For rubberband
--   selection, a node with name <tt>rubberband</tt> is used.
--   
--   The main listview node may also carry style classes to select the
--   style of <a>list presentation</a>: .rich-list, .navigation-sidebar or
--   .data-table.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkListView</tt> uses the <a>AccessibleRoleList</a> role, and the
--   list items use the <a>AccessibleRoleListItem</a> role.
module GI.Gtk.Objects.ListView

-- | Memory-managed wrapper type.
newtype ListView
ListView :: ManagedPtr ListView -> ListView

-- | Type class for types which can be safely cast to <a>ListView</a>, for
--   instance with <a>toListView</a>.
class (GObject o, IsDescendantOf ListView o) => IsListView o

-- | Cast to <a>ListView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toListView :: (MonadIO m, IsListView o) => o -> m ListView

-- | Returns whether rows can be selected by dragging with the mouse.
listViewGetEnableRubberband :: (HasCallStack, MonadIO m, IsListView a) => a -> m Bool

-- | Gets the factory that's currently used to populate list items.
listViewGetFactory :: (HasCallStack, MonadIO m, IsListView a) => a -> m (Maybe ListItemFactory)

-- | Gets the factory that's currently used to populate section headers.
--   
--   <i>Since: 4.12</i>
listViewGetHeaderFactory :: (HasCallStack, MonadIO m, IsListView a) => a -> m (Maybe ListItemFactory)

-- | Gets the model that's currently used to read the items displayed.
listViewGetModel :: (HasCallStack, MonadIO m, IsListView a) => a -> m (Maybe SelectionModel)

-- | Returns whether the listview should show separators between rows.
listViewGetShowSeparators :: (HasCallStack, MonadIO m, IsListView a) => a -> m Bool

-- | Returns whether rows will be activated on single click and selected on
--   hover.
listViewGetSingleClickActivate :: (HasCallStack, MonadIO m, IsListView a) => a -> m Bool

-- | Gets the behavior set for the &lt;kbd&gt;Tab&lt;/kbd&gt; key.
--   
--   <i>Since: 4.12</i>
listViewGetTabBehavior :: (HasCallStack, MonadIO m, IsListView a) => a -> m ListTabBehavior

-- | Creates a new <tt>GtkListView</tt> that uses the given
--   <i><tt>factory</tt></i> for mapping items to widgets.
--   
--   The function takes ownership of the arguments, so you can write code
--   like
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   list_view = gtk_list_view_new (create_model (),
--     gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
--   </pre>
listViewNew :: (HasCallStack, MonadIO m, IsSelectionModel a, IsListItemFactory b) => Maybe a -> Maybe b -> m ListView

-- | Scrolls to the item at the given position and performs the actions
--   specified in <i><tt>flags</tt></i>.
--   
--   This function works no matter if the listview is shown or focused. If
--   it isn't, then the changes will take effect once that happens.
--   
--   <i>Since: 4.12</i>
listViewScrollTo :: (HasCallStack, MonadIO m, IsListView a) => a -> Word32 -> [ListScrollFlags] -> Maybe ScrollInfo -> m ()

-- | Sets whether selections can be changed by dragging with the mouse.
listViewSetEnableRubberband :: (HasCallStack, MonadIO m, IsListView a) => a -> Bool -> m ()

-- | Sets the <tt>GtkListItemFactory</tt> to use for populating list items.
listViewSetFactory :: (HasCallStack, MonadIO m, IsListView a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkListItemFactory</tt> to use for populating the
--   <a>ListHeader</a> objects used in section headers.
--   
--   If this factory is set to <tt>NULL</tt>, the list will not show
--   section headers.
--   
--   <i>Since: 4.12</i>
listViewSetHeaderFactory :: (HasCallStack, MonadIO m, IsListView a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the model to use.
--   
--   This must be a <a>SelectionModel</a> to use.
listViewSetModel :: (HasCallStack, MonadIO m, IsListView a, IsSelectionModel b) => a -> Maybe b -> m ()

-- | Sets whether the listview should show separators between rows.
listViewSetShowSeparators :: (HasCallStack, MonadIO m, IsListView a) => a -> Bool -> m ()

-- | Sets whether rows should be activated on single click and selected on
--   hover.
listViewSetSingleClickActivate :: (HasCallStack, MonadIO m, IsListView a) => a -> Bool -> m ()

-- | Sets the &lt;kbd&gt;Tab&lt;/kbd&gt; key behavior.
--   
--   This influences how the &lt;kbd&gt;Tab&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; keys move the
--   focus in the listview.
--   
--   <i>Since: 4.12</i>
listViewSetTabBehavior :: (HasCallStack, MonadIO m, IsListView a) => a -> ListTabBehavior -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-rubberband</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructListViewEnableRubberband :: (IsListView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-rubberband</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listView #enableRubberband
--   </pre>
getListViewEnableRubberband :: (MonadIO m, IsListView o) => o -> m Bool

-- | Set the value of the “<tt>enable-rubberband</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listView [ #enableRubberband <a>:=</a> value ]
--   </pre>
setListViewEnableRubberband :: (MonadIO m, IsListView o) => o -> Bool -> m ()

-- | Set the value of the “<tt>factory</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #factory
--   </pre>
clearListViewFactory :: (MonadIO m, IsListView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>factory</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructListViewFactory :: (IsListView o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listView #factory
--   </pre>
getListViewFactory :: (MonadIO m, IsListView o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listView [ #factory <a>:=</a> value ]
--   </pre>
setListViewFactory :: (MonadIO m, IsListView o, IsListItemFactory a) => o -> a -> m ()

-- | Set the value of the “<tt>header-factory</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #headerFactory
--   </pre>
clearListViewHeaderFactory :: (MonadIO m, IsListView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>header-factory</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructListViewHeaderFactory :: (IsListView o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>header-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listView #headerFactory
--   </pre>
getListViewHeaderFactory :: (MonadIO m, IsListView o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>header-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listView [ #headerFactory <a>:=</a> value ]
--   </pre>
setListViewHeaderFactory :: (MonadIO m, IsListView o, IsListItemFactory a) => o -> a -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearListViewModel :: (MonadIO m, IsListView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructListViewModel :: (IsListView o, MonadIO m, IsSelectionModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listView #model
--   </pre>
getListViewModel :: (MonadIO m, IsListView o) => o -> m (Maybe SelectionModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listView [ #model <a>:=</a> value ]
--   </pre>
setListViewModel :: (MonadIO m, IsListView o, IsSelectionModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-separators</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructListViewShowSeparators :: (IsListView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listView #showSeparators
--   </pre>
getListViewShowSeparators :: (MonadIO m, IsListView o) => o -> m Bool

-- | Set the value of the “<tt>show-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listView [ #showSeparators <a>:=</a> value ]
--   </pre>
setListViewShowSeparators :: (MonadIO m, IsListView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>single-click-activate</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructListViewSingleClickActivate :: (IsListView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>single-click-activate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listView #singleClickActivate
--   </pre>
getListViewSingleClickActivate :: (MonadIO m, IsListView o) => o -> m Bool

-- | Set the value of the “<tt>single-click-activate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listView [ #singleClickActivate <a>:=</a> value ]
--   </pre>
setListViewSingleClickActivate :: (MonadIO m, IsListView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-behavior</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructListViewTabBehavior :: (IsListView o, MonadIO m) => ListTabBehavior -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listView #tabBehavior
--   </pre>
getListViewTabBehavior :: (MonadIO m, IsListView o) => o -> m ListTabBehavior

-- | Set the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listView [ #tabBehavior <a>:=</a> value ]
--   </pre>
setListViewTabBehavior :: (MonadIO m, IsListView o) => o -> ListTabBehavior -> m ()

-- | Emitted when a row has been activated by the user.
--   
--   Activation usually happens via the list.activate-item action of the
--   <tt>GtkListView</tt>.
--   
--   This allows for a convenient way to handle activation in a listview.
--   See <a>listItemSetActivatable</a> for details on how to use this
--   signal.
type ListViewActivateCallback = Word32 -> IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listView #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListViewActivate :: (IsListView a, MonadIO m) => a -> ((?self :: a) => ListViewActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listView #activate callback
--   </pre>
onListViewActivate :: (IsListView a, MonadIO m) => a -> ((?self :: a) => ListViewActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ListView.ListView
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListView.ListView
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListView.ListView
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListView.ListView)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListView.ListView o) => GI.Gtk.Objects.ListView.IsListView o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListView.ListView
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListView.ListView


-- | A list-like data structure that can be used with the <a>TreeView</a>.
--   
--   The <tt>GtkListStore</tt> object is a list model for use with a
--   <tt>GtkTreeView</tt> widget. It implements the <tt>GtkTreeModel</tt>
--   interface, and consequentialy, can use all of the methods available
--   there. It also implements the <tt>GtkTreeSortable</tt> interface so it
--   can be sorted by the view. Finally, it also implements the tree
--   <a>drag</a> and <a>drop</a> interfaces.
--   
--   The <tt>GtkListStore</tt> can accept most <tt>GType</tt>s as a column
--   type, though it can’t accept all custom types. Internally, it will
--   keep a copy of data passed in (such as a string or a boxed pointer).
--   Columns that accept <tt>GObject</tt>s are handled a little
--   differently. The <tt>GtkListStore</tt> will keep a reference to the
--   object instead of copying the value. As a result, if the object is
--   modified, it is up to the application writer to call
--   <a>treeModelRowChanged</a> to emit the
--   <a>signal<i><tt>gtk</tt></i>.TreeModel[row_changed</a>] signal. This
--   most commonly affects lists with <a>Texture</a>s stored.
--   
--   An example for creating a simple list store:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   enum {
--     COLUMN_STRING,
--     COLUMN_INT,
--     COLUMN_BOOLEAN,
--     N_COLUMNS
--   };
--   
--   {
--     GtkListStore *list_store;
--     GtkTreePath *path;
--     GtkTreeIter iter;
--     int i;
--   
--     list_store = gtk_list_store_new (N_COLUMNS,
--                                      G_TYPE_STRING,
--                                      G_TYPE_INT,
--                                      G_TYPE_BOOLEAN);
--   
--     for (i = 0; i &lt; 10; i++)
--       {
--         char *some_data;
--   
--         some_data = get_some_data (i);
--   
--         // Add a new row to the model
--         gtk_list_store_append (list_store, &amp;iter);
--         gtk_list_store_set (list_store, &amp;iter,
--                             COLUMN_STRING, some_data,
--                             COLUMN_INT, i,
--                             COLUMN_BOOLEAN,  FALSE,
--                             -1);
--   
--         // As the store will keep a copy of the string internally,
--         // we free some_data.
--         g_free (some_data);
--       }
--   
--     // Modify a particular row
--     path = gtk_tree_path_new_from_string ("4");
--     gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store),
--                              &amp;iter,
--                              path);
--     gtk_tree_path_free (path);
--     gtk_list_store_set (list_store, &amp;iter,
--                         COLUMN_BOOLEAN, TRUE,
--                         -1);
--   }
--   </pre>
--   
--   <tt>GtkListStore</tt> is deprecated since GTK 4.10, and should not be
--   used in newly written code. You should use <a>ListStore</a> instead,
--   and the various list models provided by GTK.
--   
--   <h2>Performance Considerations</h2>
--   
--   Internally, the <tt>GtkListStore</tt> was originally implemented with
--   a linked list with a tail pointer. As a result, it was fast at data
--   insertion and deletion, and not fast at random data access. The
--   <tt>GtkListStore</tt> sets the <tt>GTK_TREE_MODEL_ITERS_PERSIST</tt>
--   flag, which means that <tt>GtkTreeIter</tt>s can be cached while the
--   row exists. Thus, if access to a particular row is needed often and
--   your code is expected to run on older versions of GTK, it is worth
--   keeping the iter around.
--   
--   <h2>Atomic Operations</h2>
--   
--   It is important to note that only the methods
--   <tt><i>gtk_list_store_insert_with_values()</i></tt> and
--   <a>listStoreInsertWithValues</a> are atomic, in the sense that the row
--   is being appended to the store and the values filled in in a single
--   operation with regard to <tt>GtkTreeModel</tt> signaling. In contrast,
--   using e.g. <a>listStoreAppend</a> and then
--   <tt><i>gtk_list_store_set()</i></tt> will first create a row, which
--   triggers the <tt>GtkTreeModel::row-inserted</tt> signal on
--   <tt>GtkListStore</tt>. The row, however, is still empty, and any
--   signal handler connecting to <tt>GtkTreeModel::row-inserted</tt> on
--   this particular store should be prepared for the situation that the
--   row might be empty. This is especially important if you are wrapping
--   the <tt>GtkListStore</tt> inside a <tt>GtkTreeModel</tt>Filter and are
--   using a <tt>GtkTreeModel</tt>FilterVisibleFunc. Using any of the
--   non-atomic operations to append rows to the <tt>GtkListStore</tt> will
--   cause the <tt>GtkTreeModel</tt>FilterVisibleFunc to be visited with an
--   empty row first; the function must be prepared for that.
--   
--   <h2>GtkListStore as GtkBuildable</h2>
--   
--   The GtkListStore implementation of the <a>Buildable</a> interface
--   allows to specify the model columns with a <tt>&lt;columns&gt;</tt>
--   element that may contain multiple <tt>&lt;column&gt;</tt> elements,
--   each specifying one model column. The “type” attribute specifies the
--   data type for the column.
--   
--   Additionally, it is possible to specify content for the list store in
--   the UI definition, with the <tt>&lt;data&gt;</tt> element. It can
--   contain multiple <tt>&lt;row&gt;</tt> elements, each specifying to
--   content for one row of the list model. Inside a <tt>&lt;row&gt;</tt>,
--   the <tt>&lt;col&gt;</tt> elements specify the content for individual
--   cells.
--   
--   Note that it is probably more common to define your models in the
--   code, and one might consider it a layering violation to specify the
--   content of a list store in a UI definition, data, not presentation,
--   and common wisdom is to separate the two, as far as possible.
--   
--   An example of a UI Definition fragment for a list store:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkListStore"&gt;
--     &lt;columns&gt;
--       &lt;column type="gchararray"/&gt;
--       &lt;column type="gchararray"/&gt;
--       &lt;column type="gint"/&gt;
--     &lt;/columns&gt;
--     &lt;data&gt;
--       &lt;row&gt;
--         &lt;col id="0"&gt;John&lt;/col&gt;
--         &lt;col id="1"&gt;Doe&lt;/col&gt;
--         &lt;col id="2"&gt;25&lt;/col&gt;
--       &lt;/row&gt;
--       &lt;row&gt;
--         &lt;col id="0"&gt;Johan&lt;/col&gt;
--         &lt;col id="1"&gt;Dahlin&lt;/col&gt;
--         &lt;col id="2"&gt;50&lt;/col&gt;
--       &lt;/row&gt;
--     &lt;/data&gt;
--   &lt;/object&gt;
--   </pre>
module GI.Gtk.Objects.ListStore

-- | Memory-managed wrapper type.
newtype ListStore
ListStore :: ManagedPtr ListStore -> ListStore

-- | Type class for types which can be safely cast to <a>ListStore</a>, for
--   instance with <a>toListStore</a>.
class (GObject o, IsDescendantOf ListStore o) => IsListStore o

-- | Cast to <a>ListStore</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toListStore :: (MonadIO m, IsListStore o) => o -> m ListStore

-- | Appends a new row to <i><tt>listStore</tt></i>. <i><tt>iter</tt></i>
--   will be changed to point to this new row. The row will be empty after
--   this function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreAppend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m TreeIter

-- | Removes all rows from the list store.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreClear :: (HasCallStack, MonadIO m, IsListStore a) => a -> m ()

-- | Creates a new row at <i><tt>position</tt></i>. <i><tt>iter</tt></i>
--   will be changed to point to this new row. If <i><tt>position</tt></i>
--   is -1 or is larger than the number of rows on the list, then the new
--   row will be appended to the list. The row will be empty after this
--   function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreInsert :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> m TreeIter

-- | Inserts a new row after <i><tt>sibling</tt></i>. If
--   <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   prepended to the beginning of the list. <i><tt>iter</tt></i> will be
--   changed to point to this new row. The row will be empty after this
--   function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreInsertAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

-- | Inserts a new row before <i><tt>sibling</tt></i>. If
--   <i><tt>sibling</tt></i> is <a>Nothing</a>, then the row will be
--   appended to the end of the list. <i><tt>iter</tt></i> will be changed
--   to point to this new row. The row will be empty after this function is
--   called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreInsertBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> Maybe TreeIter -> m TreeIter

-- | A variant of <tt><i>gtk_list_store_insert_with_values()</i></tt> which
--   takes the columns and values as two arrays, instead of varargs.
--   
--   This function is mainly intended for language-bindings.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreInsertWithValues :: (HasCallStack, MonadIO m, IsListStore a) => a -> Int32 -> [Int32] -> [GValue] -> m TreeIter

-- | Checks if the given iter is a valid iter for this
--   <tt>GtkListStore</tt>.
--   
--   This function is slow. Only use it for debugging and/or testing
--   purposes.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreIterIsValid :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> m Bool

-- | Moves <i><tt>iter</tt></i> in <i><tt>store</tt></i> to the position
--   after <i><tt>position</tt></i>. Note that this function only works
--   with unsorted stores. If <i><tt>position</tt></i> is <a>Nothing</a>,
--   <i><tt>iter</tt></i> will be moved to the start of the list.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreMoveAfter :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Moves <i><tt>iter</tt></i> in <i><tt>store</tt></i> to the position
--   before <i><tt>position</tt></i>. Note that this function only works
--   with unsorted stores. If <i><tt>position</tt></i> is <a>Nothing</a>,
--   <i><tt>iter</tt></i> will be moved to the end of the list.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreMoveBefore :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Maybe TreeIter -> m ()

-- | Creates a new <tt>GtkListStore</tt>.
--   
--   This function is meant to be used by language bindings.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListStore</a> instead</i>
listStoreNew :: (HasCallStack, MonadIO m) => [GType] -> m ListStore

-- | Prepends a new row to <i><tt>listStore</tt></i>. <i><tt>iter</tt></i>
--   will be changed to point to this new row. The row will be empty after
--   this function is called. To fill in values, you need to call
--   <tt><i>gtk_list_store_set()</i></tt> or <a>listStoreSetValue</a>.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStorePrepend :: (HasCallStack, MonadIO m, IsListStore a) => a -> m TreeIter

-- | Removes the given row from the list store. After being removed,
--   <i><tt>iter</tt></i> is set to be the next valid row, or invalidated
--   if it pointed to the last row in <i><tt>listStore</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreRemove :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> m Bool

-- | Reorders <i><tt>store</tt></i> to follow the order indicated by
--   <i><tt>newOrder</tt></i>. Note that this function only works with
--   unsorted stores.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreReorder :: (HasCallStack, MonadIO m, IsListStore a) => a -> [Int32] -> m ()

-- | A variant of <tt><i>gtk_list_store_set_valist()</i></tt> which takes
--   the columns and values as two arrays, instead of varargs. This
--   function is mainly intended for language-bindings and in case the
--   number of columns to change is not known until run-time.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreSet :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> [Int32] -> [GValue] -> m ()

-- | Sets the types of the columns of a list store.
--   
--   This function is meant primarily for objects that inherit from
--   <tt>GtkListStore</tt>, and should only be used when constructing a new
--   instance.
--   
--   This function cannot be called after a row has been added, or a method
--   on the <tt>GtkTreeModel</tt> interface is called.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreSetColumnTypes :: (HasCallStack, MonadIO m, IsListStore a) => a -> [GType] -> m ()

-- | Sets the data in the cell specified by <i><tt>iter</tt></i> and
--   <i><tt>column</tt></i>. The type of <i><tt>value</tt></i> must be
--   convertible to the type of the column.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreSetValue :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> Int32 -> GValue -> m ()

-- | Swaps <i><tt>a</tt></i> and <i><tt>b</tt></i> in
--   <i><tt>store</tt></i>. Note that this function only works with
--   unsorted stores.

-- | <i>Deprecated: (Since version 4.10)Use list models</i>
listStoreSwap :: (HasCallStack, MonadIO m, IsListStore a) => a -> TreeIter -> TreeIter -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ListStore.ListStore
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListStore.ListStore
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListStore.ListStore
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListStore.ListStore)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListStore.ListStore o) => GI.Gtk.Objects.ListStore.IsListStore o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListStore.ListStore
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListStore.ListStore


-- | Used by list widgets to represent items in a <a>ListModel</a>.
--   
--   <tt>GtkListItem</tt> objects are managed by the list widget (with its
--   factory) and cannot be created by applications, but they need to be
--   populated by application code. This is done by calling
--   <a>listItemSetChild</a>.
--   
--   <tt>GtkListItem</tt> objects exist in 2 stages:
--   
--   <ol>
--   <li>The unbound stage where the listitem is not currently connected to
--   an item in the list. In that case, the <a>ListItem:item</a> property
--   is set to <tt>NULL</tt>.</li>
--   <li>The bound stage where the listitem references an item from the
--   list. The <a>ListItem:item</a> property is not <tt>NULL</tt>.</li>
--   </ol>
module GI.Gtk.Objects.ListItem

-- | Memory-managed wrapper type.
newtype ListItem
ListItem :: ManagedPtr ListItem -> ListItem

-- | Type class for types which can be safely cast to <a>ListItem</a>, for
--   instance with <a>toListItem</a>.
class (GObject o, IsDescendantOf ListItem o) => IsListItem o

-- | Cast to <a>ListItem</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toListItem :: (MonadIO m, IsListItem o) => o -> m ListItem

-- | Gets the accessible description of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.12</i>
listItemGetAccessibleDescription :: (HasCallStack, MonadIO m, IsListItem a) => a -> m Text

-- | Gets the accessible label of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.12</i>
listItemGetAccessibleLabel :: (HasCallStack, MonadIO m, IsListItem a) => a -> m Text

-- | Checks if a listitem has been set to be activatable via
--   <a>listItemSetActivatable</a>.
listItemGetActivatable :: (HasCallStack, MonadIO m, IsListItem a) => a -> m Bool

-- | Gets the child previously set via <a>listItemSetChild</a> or
--   <tt>NULL</tt> if none was set.
listItemGetChild :: (HasCallStack, MonadIO m, IsListItem a) => a -> m (Maybe Widget)

-- | Checks if a listitem has been set to be focusable via
--   <a>listItemSetFocusable</a>.
--   
--   <i>Since: 4.12</i>
listItemGetFocusable :: (HasCallStack, MonadIO m, IsListItem a) => a -> m Bool

-- | Gets the model item that associated with <i><tt>self</tt></i>.
--   
--   If <i><tt>self</tt></i> is unbound, this function returns
--   <tt>NULL</tt>.
listItemGetItem :: (HasCallStack, MonadIO m, IsListItem a) => a -> m (Maybe Object)

-- | Gets the position in the model that <i><tt>self</tt></i> currently
--   displays.
--   
--   If <i><tt>self</tt></i> is unbound, <tt>GTK_INVALID_LIST_POSITION</tt>
--   is returned.
listItemGetPosition :: (HasCallStack, MonadIO m, IsListItem a) => a -> m Word32

-- | Checks if a listitem has been set to be selectable via
--   <a>listItemSetSelectable</a>.
--   
--   Do not confuse this function with <a>listItemGetSelected</a>.
listItemGetSelectable :: (HasCallStack, MonadIO m, IsListItem a) => a -> m Bool

-- | Checks if the item is displayed as selected.
--   
--   The selected state is maintained by the list widget and its model and
--   cannot be set otherwise.
listItemGetSelected :: (HasCallStack, MonadIO m, IsListItem a) => a -> m Bool

-- | Sets the accessible description for the listitem.
--   
--   The accessible description may be used by e.g. screen readers.
--   
--   <i>Since: 4.12</i>
listItemSetAccessibleDescription :: (HasCallStack, MonadIO m, IsListItem a) => a -> Text -> m ()

-- | Sets the accessible label for the listitem.
--   
--   The accessible label may be used by e.g. screen readers.
--   
--   <i>Since: 4.12</i>
listItemSetAccessibleLabel :: (HasCallStack, MonadIO m, IsListItem a) => a -> Text -> m ()

-- | Sets <i><tt>self</tt></i> to be activatable.
--   
--   If an item is activatable, double-clicking on the item, using the
--   Return key or calling <a>widgetActivate</a> will activate the item.
--   Activating instructs the containing view to handle activation.
--   <tt>GtkListView</tt> for example will be emitting the
--   <a>ListView::activate</a> signal.
--   
--   By default, listitems are activatable.
listItemSetActivatable :: (HasCallStack, MonadIO m, IsListItem a) => a -> Bool -> m ()

-- | Sets the child to be used for this listitem.
--   
--   This function is typically called by applications when setting up a
--   listitem so that the widget can be reused when binding it multiple
--   times.
listItemSetChild :: (HasCallStack, MonadIO m, IsListItem a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets <i><tt>self</tt></i> to be focusable.
--   
--   If an item is focusable, it can be focused using the keyboard. This
--   works similar to <a>widgetSetFocusable</a>.
--   
--   Note that if items are not focusable, the keyboard cannot be used to
--   activate them and selecting only works if one of the listitem's
--   children is focusable.
--   
--   By default, listitems are focusable.
--   
--   <i>Since: 4.12</i>
listItemSetFocusable :: (HasCallStack, MonadIO m, IsListItem a) => a -> Bool -> m ()

-- | Sets <i><tt>self</tt></i> to be selectable.
--   
--   If an item is selectable, clicking on the item or using the keyboard
--   will try to select or unselect the item. If this succeeds is up to the
--   model to determine, as it is managing the selected state.
--   
--   Note that this means that making an item non-selectable has no
--   influence on the selected state at all. A non-selectable item may
--   still be selected.
--   
--   By default, listitems are selectable. When rebinding them to a new
--   item, they will also be reset to be selectable by GTK.
listItemSetSelectable :: (HasCallStack, MonadIO m, IsListItem a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accessible-description</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructListItemAccessibleDescription :: (IsListItem o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accessible-description</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #accessibleDescription
--   </pre>
getListItemAccessibleDescription :: (MonadIO m, IsListItem o) => o -> m Text

-- | Set the value of the “<tt>accessible-description</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listItem [ #accessibleDescription <a>:=</a> value ]
--   </pre>
setListItemAccessibleDescription :: (MonadIO m, IsListItem o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accessible-label</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructListItemAccessibleLabel :: (IsListItem o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accessible-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #accessibleLabel
--   </pre>
getListItemAccessibleLabel :: (MonadIO m, IsListItem o) => o -> m Text

-- | Set the value of the “<tt>accessible-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listItem [ #accessibleLabel <a>:=</a> value ]
--   </pre>
setListItemAccessibleLabel :: (MonadIO m, IsListItem o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activatable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructListItemActivatable :: (IsListItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #activatable
--   </pre>
getListItemActivatable :: (MonadIO m, IsListItem o) => o -> m Bool

-- | Set the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listItem [ #activatable <a>:=</a> value ]
--   </pre>
setListItemActivatable :: (MonadIO m, IsListItem o) => o -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearListItemChild :: (MonadIO m, IsListItem o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructListItemChild :: (IsListItem o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #child
--   </pre>
getListItemChild :: (MonadIO m, IsListItem o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listItem [ #child <a>:=</a> value ]
--   </pre>
setListItemChild :: (MonadIO m, IsListItem o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focusable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructListItemFocusable :: (IsListItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #focusable
--   </pre>
getListItemFocusable :: (MonadIO m, IsListItem o) => o -> m Bool

-- | Set the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listItem [ #focusable <a>:=</a> value ]
--   </pre>
setListItemFocusable :: (MonadIO m, IsListItem o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #item
--   </pre>
getListItemItem :: (MonadIO m, IsListItem o) => o -> m (Maybe Object)

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #position
--   </pre>
getListItemPosition :: (MonadIO m, IsListItem o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selectable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructListItemSelectable :: (IsListItem o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #selectable
--   </pre>
getListItemSelectable :: (MonadIO m, IsListItem o) => o -> m Bool

-- | Set the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listItem [ #selectable <a>:=</a> value ]
--   </pre>
setListItemSelectable :: (MonadIO m, IsListItem o) => o -> Bool -> m ()

-- | Get the value of the “<tt>selected</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listItem #selected
--   </pre>
getListItemSelected :: (MonadIO m, IsListItem o) => o -> m Bool
instance GHC.Classes.Eq GI.Gtk.Objects.ListItem.ListItem
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListItem.ListItem
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListItem.ListItem
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListItem.ListItem)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListItem.ListItem o) => GI.Gtk.Objects.ListItem.IsListItem o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListItem.ListItem
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListItem.ListItem


-- | Used by list widgets to represent the headers they display.
--   
--   <tt>GtkListHeader</tt> objects are managed just like <a>ListItem</a>
--   objects via their factory, but provide a different set of properties
--   suitable for managing the header instead of individual items.
--   
--   <i>Since: 4.12</i>
module GI.Gtk.Objects.ListHeader

-- | Memory-managed wrapper type.
newtype ListHeader
ListHeader :: ManagedPtr ListHeader -> ListHeader

-- | Type class for types which can be safely cast to <a>ListHeader</a>,
--   for instance with <a>toListHeader</a>.
class (GObject o, IsDescendantOf ListHeader o) => IsListHeader o

-- | Cast to <a>ListHeader</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toListHeader :: (MonadIO m, IsListHeader o) => o -> m ListHeader

-- | Gets the child previously set via <a>listHeaderSetChild</a> or
--   <a>Nothing</a> if none was set.
--   
--   <i>Since: 4.12</i>
listHeaderGetChild :: (HasCallStack, MonadIO m, IsListHeader a) => a -> m (Maybe Widget)

-- | Gets the end position in the model of the section that
--   <i><tt>self</tt></i> is currently the header for.
--   
--   If <i><tt>self</tt></i> is unbound, <a>INVALID_LIST_POSITION</a> is
--   returned.
--   
--   <i>Since: 4.12</i>
listHeaderGetEnd :: (HasCallStack, MonadIO m, IsListHeader a) => a -> m Word32

-- | Gets the model item at the start of the section. This is the item that
--   occupies the list model at position <a>ListHeader:start</a>.
--   
--   If <i><tt>self</tt></i> is unbound, this function returns
--   <a>Nothing</a>.
--   
--   <i>Since: 4.12</i>
listHeaderGetItem :: (HasCallStack, MonadIO m, IsListHeader a) => a -> m (Maybe Object)

-- | Gets the the number of items in the section.
--   
--   If <i><tt>self</tt></i> is unbound, 0 is returned.
--   
--   <i>Since: 4.12</i>
listHeaderGetNItems :: (HasCallStack, MonadIO m, IsListHeader a) => a -> m Word32

-- | Gets the start position in the model of the section that
--   <i><tt>self</tt></i> is currently the header for.
--   
--   If <i><tt>self</tt></i> is unbound, <a>INVALID_LIST_POSITION</a> is
--   returned.
--   
--   <i>Since: 4.12</i>
listHeaderGetStart :: (HasCallStack, MonadIO m, IsListHeader a) => a -> m Word32

-- | Sets the child to be used for this listitem.
--   
--   This function is typically called by applications when setting up a
--   header so that the widget can be reused when binding it multiple
--   times.
--   
--   <i>Since: 4.12</i>
listHeaderSetChild :: (HasCallStack, MonadIO m, IsListHeader a, IsWidget b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearListHeaderChild :: (MonadIO m, IsListHeader o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructListHeaderChild :: (IsListHeader o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listHeader #child
--   </pre>
getListHeaderChild :: (MonadIO m, IsListHeader o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listHeader [ #child <a>:=</a> value ]
--   </pre>
setListHeaderChild :: (MonadIO m, IsListHeader o, IsWidget a) => o -> a -> m ()

-- | Get the value of the “<tt>end</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listHeader #end
--   </pre>
getListHeaderEnd :: (MonadIO m, IsListHeader o) => o -> m Word32

-- | Get the value of the “<tt>item</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listHeader #item
--   </pre>
getListHeaderItem :: (MonadIO m, IsListHeader o) => o -> m (Maybe Object)

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listHeader #nItems
--   </pre>
getListHeaderNItems :: (MonadIO m, IsListHeader o) => o -> m Word32

-- | Get the value of the “<tt>start</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listHeader #start
--   </pre>
getListHeaderStart :: (MonadIO m, IsListHeader o) => o -> m Word32
instance GHC.Classes.Eq GI.Gtk.Objects.ListHeader.ListHeader
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListHeader.ListHeader
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListHeader.ListHeader
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListHeader.ListHeader)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListHeader.ListHeader o) => GI.Gtk.Objects.ListHeader.IsListHeader o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListHeader.ListHeader
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListHeader.ListHeader


-- | The kind of widget that can be added to a <tt>GtkListBox</tt>.
--   
--   <a>ListBox</a> will automatically wrap its children in a
--   <tt>GtkListboxRow</tt> when necessary.
module GI.Gtk.Objects.ListBoxRow

-- | Memory-managed wrapper type.
newtype ListBoxRow
ListBoxRow :: ManagedPtr ListBoxRow -> ListBoxRow

-- | Type class for types which can be safely cast to <a>ListBoxRow</a>,
--   for instance with <a>toListBoxRow</a>.
class (GObject o, IsDescendantOf ListBoxRow o) => IsListBoxRow o

-- | Cast to <a>ListBoxRow</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toListBoxRow :: (MonadIO m, IsListBoxRow o) => o -> m ListBoxRow

-- | Marks <i><tt>row</tt></i> as changed, causing any state that depends
--   on this to be updated.
--   
--   This affects sorting, filtering and headers.
--   
--   Note that calls to this method must be in sync with the data used for
--   the row functions. For instance, if the list is mirroring some
--   external data set, and *two* rows changed in the external data set
--   then when you call <a>listBoxRowChanged</a> on the first row the sort
--   function must only read the new data for the first of the two changed
--   rows, otherwise the resorting of the rows will be wrong.
--   
--   This generally means that if you don’t fully control the data model
--   you have to duplicate the data that affects the listbox row functions
--   into the row widgets themselves. Another alternative is to call
--   <a>listBoxInvalidateSort</a> on any model change, but that is more
--   expensive.
listBoxRowChanged :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m ()

-- | Gets whether the row is activatable.
listBoxRowGetActivatable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Gets the child widget of <i><tt>row</tt></i>.
listBoxRowGetChild :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m (Maybe Widget)

-- | Returns the current header of the <i><tt>row</tt></i>.
--   
--   This can be used in a
--   [callback<i><tt>gtk</tt></i>.ListBoxUpdateHeaderFunc] to see if there
--   is a header set already, and if so to update the state of it.
listBoxRowGetHeader :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m (Maybe Widget)

-- | Gets the current index of the <i><tt>row</tt></i> in its
--   <tt>GtkListBox</tt> container.
listBoxRowGetIndex :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Int32

-- | Gets whether the row can be selected.
listBoxRowGetSelectable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Returns whether the child is currently selected in its
--   <tt>GtkListBox</tt> container.
listBoxRowIsSelected :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> m Bool

-- | Creates a new <tt>GtkListBoxRow</tt>.
listBoxRowNew :: (HasCallStack, MonadIO m) => m ListBoxRow

-- | Set whether the row is activatable.
listBoxRowSetActivatable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> Bool -> m ()

-- | Sets the child widget of <i><tt>self</tt></i>.
listBoxRowSetChild :: (HasCallStack, MonadIO m, IsListBoxRow a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the current header of the <i><tt>row</tt></i>.
--   
--   This is only allowed to be called from a
--   [callback<i><tt>gtk</tt></i>.ListBoxUpdateHeaderFunc]. It will replace
--   any existing header in the row, and be shown in front of the row in
--   the listbox.
listBoxRowSetHeader :: (HasCallStack, MonadIO m, IsListBoxRow a, IsWidget b) => a -> Maybe b -> m ()

-- | Set whether the row can be selected.
listBoxRowSetSelectable :: (HasCallStack, MonadIO m, IsListBoxRow a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activatable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructListBoxRowActivatable :: (IsListBoxRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBoxRow #activatable
--   </pre>
getListBoxRowActivatable :: (MonadIO m, IsListBoxRow o) => o -> m Bool

-- | Set the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBoxRow [ #activatable <a>:=</a> value ]
--   </pre>
setListBoxRowActivatable :: (MonadIO m, IsListBoxRow o) => o -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearListBoxRowChild :: (MonadIO m, IsListBoxRow o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructListBoxRowChild :: (IsListBoxRow o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBoxRow #child
--   </pre>
getListBoxRowChild :: (MonadIO m, IsListBoxRow o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBoxRow [ #child <a>:=</a> value ]
--   </pre>
setListBoxRowChild :: (MonadIO m, IsListBoxRow o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selectable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructListBoxRowSelectable :: (IsListBoxRow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBoxRow #selectable
--   </pre>
getListBoxRowSelectable :: (MonadIO m, IsListBoxRow o) => o -> m Bool

-- | Set the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBoxRow [ #selectable <a>:=</a> value ]
--   </pre>
setListBoxRowSelectable :: (MonadIO m, IsListBoxRow o) => o -> Bool -> m ()

-- | This is a keybinding signal, which will cause this row to be
--   activated.
--   
--   If you want to be notified when the user activates a row (by key or
--   not), use the <a>ListBox::rowActivated</a> signal on the row’s parent
--   <tt>GtkListBox</tt>.
type ListBoxRowActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBoxRow #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxRowActivate :: (IsListBoxRow a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBoxRow #activate callback
--   </pre>
onListBoxRowActivate :: (IsListBoxRow a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ListBoxRow.ListBoxRow
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListBoxRow.ListBoxRow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListBoxRow.ListBoxRow
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListBoxRow.ListBoxRow)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListBoxRow.ListBoxRow o) => GI.Gtk.Objects.ListBoxRow.IsListBoxRow o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListBoxRow.ListBoxRow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListBoxRow.ListBoxRow


-- | Shows a vertical list.
--   
--   &lt;picture&gt; &lt;source srcset="list-box-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkListBox" src="list-box.png"&gt; &lt;/picture&gt;
--   
--   A <tt>GtkListBox</tt> only contains <tt>GtkListBoxRow</tt> children.
--   These rows can by dynamically sorted and filtered, and headers can be
--   added dynamically depending on the row content. It also allows
--   keyboard and mouse navigation and selection like a typical list.
--   
--   Using <tt>GtkListBox</tt> is often an alternative to
--   <tt>GtkTreeView</tt>, especially when the list contents has a more
--   complicated layout than what is allowed by a <tt>GtkCellRenderer</tt>,
--   or when the contents is interactive (i.e. has a button in it).
--   
--   Although a <tt>GtkListBox</tt> must have only <tt>GtkListBoxRow</tt>
--   children, you can add any kind of widget to it via
--   <a>listBoxPrepend</a>, <a>listBoxAppend</a> and <a>listBoxInsert</a>
--   and a <tt>GtkListBoxRow</tt> widget will automatically be inserted
--   between the list and the widget.
--   
--   <tt>GtkListBoxRows</tt> can be marked as activatable or selectable. If
--   a row is activatable, <a>ListBox::rowActivated</a> will be emitted for
--   it when the user tries to activate it. If it is selectable, the row
--   will be marked as selected when the user tries to select it.
--   
--   <h1>GtkListBox as GtkBuildable</h1>
--   
--   The <tt>GtkListBox</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports setting a child as the placeholder by specifying
--   “placeholder” as the “type” attribute of a <tt>&lt;child&gt;</tt>
--   element. See <a>listBoxSetPlaceholder</a> for info.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>ListBox::moveCursor</a></li>
--   <li><a>ListBox::selectAll</a></li>
--   <li><a>ListBox::toggleCursorRow</a></li>
--   <li><a>ListBox::unselectAll</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   list[.separators][.rich-list][.navigation-sidebar][.boxed-list]
--   ╰── row[.activatable]
--   </pre>
--   
--   <tt>GtkListBox</tt> uses a single CSS node named list. It may carry
--   the .separators style class, when the <a>ListBox:showSeparators</a>
--   property is set. Each <tt>GtkListBoxRow</tt> uses a single CSS node
--   named row. The row nodes get the .activatable style class added when
--   appropriate.
--   
--   It may also carry the .boxed-list style class. In this case, the list
--   will be automatically surrounded by a frame and have separators.
--   
--   The main list node may also carry style classes to select the style of
--   <a>list presentation</a>: .rich-list, .navigation-sidebar or
--   .data-table.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkListBox</tt> uses the <a>AccessibleRoleList</a> role and
--   <tt>GtkListBoxRow</tt> uses the <a>AccessibleRoleListItem</a> role.
module GI.Gtk.Objects.ListBox

-- | Memory-managed wrapper type.
newtype ListBox
ListBox :: ManagedPtr ListBox -> ListBox

-- | Type class for types which can be safely cast to <a>ListBox</a>, for
--   instance with <a>toListBox</a>.
class (GObject o, IsDescendantOf ListBox o) => IsListBox o

-- | Cast to <a>ListBox</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toListBox :: (MonadIO m, IsListBox o) => o -> m ListBox

-- | Append a widget to the list.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position.
listBoxAppend :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> m ()

-- | Binds <i><tt>model</tt></i> to <i><tt>box</tt></i>.
--   
--   If <i><tt>box</tt></i> was already bound to a model, that previous
--   binding is destroyed.
--   
--   The contents of <i><tt>box</tt></i> are cleared and then filled with
--   widgets that represent items from <i><tt>model</tt></i>.
--   <i><tt>box</tt></i> is updated whenever <i><tt>model</tt></i> changes.
--   If <i><tt>model</tt></i> is <a>Nothing</a>, <i><tt>box</tt></i> is
--   left empty.
--   
--   It is undefined to add or remove widgets directly (for example, with
--   <a>listBoxInsert</a>) while <i><tt>box</tt></i> is bound to a model.
--   
--   Note that using a model is incompatible with the filtering and sorting
--   functionality in <tt>GtkListBox</tt>. When using a model, filtering
--   and sorting should be implemented by the model.
listBoxBindModel :: (HasCallStack, MonadIO m, IsListBox a, IsListModel b) => a -> Maybe b -> Maybe ListBoxCreateWidgetFunc -> m ()

-- | Add a drag highlight to a row.
--   
--   This is a helper function for implementing DnD onto a
--   <tt>GtkListBox</tt>. The passed in <i><tt>row</tt></i> will be
--   highlighted by setting the <a>StateFlagsDropActive</a> state and any
--   previously highlighted row will be unhighlighted.
--   
--   The row will also be unhighlighted when the widget gets a drag leave
--   event.
listBoxDragHighlightRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()

-- | If a row has previously been highlighted via
--   <a>listBoxDragHighlightRow</a>, it will have the highlight removed.
listBoxDragUnhighlightRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Returns whether rows activate on single clicks.
listBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Bool

-- | Gets the adjustment (if any) that the widget uses to for vertical
--   scrolling.
listBoxGetAdjustment :: (HasCallStack, MonadIO m, IsListBox a) => a -> m (Maybe Adjustment)

-- | Gets the n-th child in the list (not counting headers).
--   
--   If <i><tt>index_</tt></i> is negative or larger than the number of
--   items in the list, <a>Nothing</a> is returned.
listBoxGetRowAtIndex :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)

-- | Gets the row at the <i><tt>y</tt></i> position.
listBoxGetRowAtY :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)

-- | Gets the selected row, or <a>Nothing</a> if no rows are selected.
--   
--   Note that the box may allow multiple selection, in which case you
--   should use <a>listBoxSelectedForeach</a> to find all selected rows.
listBoxGetSelectedRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m (Maybe ListBoxRow)

-- | Creates a list of all selected children.
listBoxGetSelectedRows :: (HasCallStack, MonadIO m, IsListBox a) => a -> m [ListBoxRow]

-- | Gets the selection mode of the listbox.
listBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> m SelectionMode

-- | Returns whether the list box should show separators between rows.
listBoxGetShowSeparators :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Bool

-- | Returns the behavior of the &lt;kbd&gt;Tab&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; keys.
--   
--   <i>Since: 4.18</i>
listBoxGetTabBehavior :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ListTabBehavior

-- | Insert the <i><tt>child</tt></i> into the <i><tt>box</tt></i> at
--   <i><tt>position</tt></i>.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position.
--   
--   If <i><tt>position</tt></i> is -1, or larger than the total number of
--   items in the <i><tt>box</tt></i>, then the <i><tt>child</tt></i> will
--   be appended to the end.
listBoxInsert :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Update the filtering for all rows.
--   
--   Call this when result of the filter function on the
--   <i><tt>box</tt></i> is changed due to an external factor. For
--   instance, this would be used if the filter function just looked for a
--   specific search string and the entry with the search string has
--   changed.
listBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Update the separators for all rows.
--   
--   Call this when result of the header function on the
--   <i><tt>box</tt></i> is changed due to an external factor.
listBoxInvalidateHeaders :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Update the sorting for all rows.
--   
--   Call this when result of the sort function on the <i><tt>box</tt></i>
--   is changed due to an external factor.
listBoxInvalidateSort :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Creates a new <tt>GtkListBox</tt> container.
listBoxNew :: (HasCallStack, MonadIO m) => m ListBox

-- | Prepend a widget to the list.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position.
listBoxPrepend :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> m ()

-- | Removes a child from <i><tt>box</tt></i>.
listBoxRemove :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> m ()

-- | Removes all rows from <i><tt>box</tt></i>.
--   
--   This function does nothing if <i><tt>box</tt></i> is backed by a
--   model.
--   
--   <i>Since: 4.12</i>
listBoxRemoveAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Select all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
listBoxSelectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Make <i><tt>row</tt></i> the currently selected row.
listBoxSelectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> Maybe b -> m ()

-- | Calls a function for each selected child.
--   
--   Note that the selection cannot be modified from within this function.
listBoxSelectedForeach :: (HasCallStack, MonadIO m, IsListBox a) => a -> ListBoxForeachFunc -> m ()

-- | If <i><tt>single</tt></i> is <a>True</a>, rows will be activated when
--   you click on them, otherwise you need to double-click.
listBoxSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> Bool -> m ()

-- | Sets the adjustment (if any) that the widget uses to for vertical
--   scrolling.
--   
--   For instance, this is used to get the page size for PageUp/Down key
--   handling.
--   
--   In the normal case when the <i><tt>box</tt></i> is packed inside a
--   <tt>GtkScrolledWindow</tt> the adjustment from that will be picked up
--   automatically, so there is no need to manually do that.
listBoxSetAdjustment :: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) => a -> Maybe b -> m ()

-- | By setting a filter function on the <i><tt>box</tt></i> one can decide
--   dynamically which of the rows to show.
--   
--   For instance, to implement a search function on a list that filters
--   the original list to only show the matching rows.
--   
--   The <i><tt>filterFunc</tt></i> will be called for each row after the
--   call, and it will continue to be called each time a row changes (via
--   <a>listBoxRowChanged</a>) or when <a>listBoxInvalidateFilter</a> is
--   called.
--   
--   Note that using a filter function is incompatible with using a model
--   (see <a>listBoxBindModel</a>).
listBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxFilterFunc -> m ()

-- | Sets a header function.
--   
--   By setting a header function on the <i><tt>box</tt></i> one can
--   dynamically add headers in front of rows, depending on the contents of
--   the row and its position in the list.
--   
--   For instance, one could use it to add headers in front of the first
--   item of a new kind, in a list sorted by the kind.
--   
--   The <i><tt>updateHeader</tt></i> can look at the current header widget
--   using <a>listBoxRowGetHeader</a> and either update the state of the
--   widget as needed, or set a new one using <a>listBoxRowSetHeader</a>.
--   If no header is needed, set the header to <a>Nothing</a>.
--   
--   Note that you may get many calls <i><tt>updateHeader</tt></i> to this
--   for a particular row when e.g. changing things that don’t affect the
--   header. In this case it is important for performance to not blindly
--   replace an existing header with an identical one.
--   
--   The <i><tt>updateHeader</tt></i> function will be called for each row
--   after the call, and it will continue to be called each time a row
--   changes (via <a>listBoxRowChanged</a>) and when the row before changes
--   (either by <a>listBoxRowChanged</a> on the previous row, or when the
--   previous row becomes a different row). It is also called for all rows
--   when <a>listBoxInvalidateHeaders</a> is called.
listBoxSetHeaderFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxUpdateHeaderFunc -> m ()

-- | Sets the placeholder widget that is shown in the list when it doesn't
--   display any visible children.
listBoxSetPlaceholder :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets how selection works in the listbox.
listBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> SelectionMode -> m ()

-- | Sets whether the list box should show separators between rows.
listBoxSetShowSeparators :: (HasCallStack, MonadIO m, IsListBox a) => a -> Bool -> m ()

-- | Sets a sort function.
--   
--   By setting a sort function on the <i><tt>box</tt></i> one can
--   dynamically reorder the rows of the list, based on the contents of the
--   rows.
--   
--   The <i><tt>sortFunc</tt></i> will be called for each row after the
--   call, and will continue to be called each time a row changes (via
--   <a>listBoxRowChanged</a>) and when <a>listBoxInvalidateSort</a> is
--   called.
--   
--   Note that using a sort function is incompatible with using a model
--   (see <a>listBoxBindModel</a>).
listBoxSetSortFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxSortFunc -> m ()

-- | Sets the behavior of the &lt;kbd&gt;Tab&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; keys.
--   
--   <i>Since: 4.18</i>
listBoxSetTabBehavior :: (HasCallStack, MonadIO m, IsListBox a) => a -> ListTabBehavior -> m ()

-- | Unselect all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
listBoxUnselectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()

-- | Unselects a single row of <i><tt>box</tt></i>, if the selection mode
--   allows it.
listBoxUnselectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accept-unpaired-release</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructListBoxAcceptUnpairedRelease :: (IsListBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>accept-unpaired-release</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBox #acceptUnpairedRelease
--   </pre>
getListBoxAcceptUnpairedRelease :: (MonadIO m, IsListBox o) => o -> m Bool

-- | Set the value of the “<tt>accept-unpaired-release</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBox [ #acceptUnpairedRelease <a>:=</a> value ]
--   </pre>
setListBoxAcceptUnpairedRelease :: (MonadIO m, IsListBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructListBoxActivateOnSingleClick :: (IsListBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBox #activateOnSingleClick
--   </pre>
getListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBox [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selection-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructListBoxSelectionMode :: (IsListBox o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBox #selectionMode
--   </pre>
getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode

-- | Set the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBox [ #selectionMode <a>:=</a> value ]
--   </pre>
setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-separators</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructListBoxShowSeparators :: (IsListBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBox #showSeparators
--   </pre>
getListBoxShowSeparators :: (MonadIO m, IsListBox o) => o -> m Bool

-- | Set the value of the “<tt>show-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBox [ #showSeparators <a>:=</a> value ]
--   </pre>
setListBoxShowSeparators :: (MonadIO m, IsListBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-behavior</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructListBoxTabBehavior :: (IsListBox o, MonadIO m) => ListTabBehavior -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBox #tabBehavior
--   </pre>
getListBoxTabBehavior :: (MonadIO m, IsListBox o) => o -> m ListTabBehavior

-- | Set the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBox [ #tabBehavior <a>:=</a> value ]
--   </pre>
setListBoxTabBehavior :: (MonadIO m, IsListBox o) => o -> ListTabBehavior -> m ()

-- | Emitted when the cursor row is activated.
type ListBoxActivateCursorRowCallback = IO ()

-- | Connect a signal handler for the <a>activateCursorRow</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> listBox #activateCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxActivateCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCursorRow</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #activateCursorRow callback
--   </pre>
onListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxActivateCursorRowCallback) -> m SignalHandlerId

-- | Emitted when the user initiates a cursor movement.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the Shift modifier extends the selection, the variant without the
--   Shift modifier does not. There are too many key combinations to list
--   them all here.
--   
--   <ul>
--   <li>&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;↑&lt;/kbd&gt;, &lt;kbd&gt;↓&lt;/kbd&gt; move by individual
--   children</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt;, &lt;kbd&gt;End&lt;/kbd&gt; move to
--   the ends of the box</li>
--   <li>&lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;PgDn&lt;/kbd&gt; move
--   vertically by pages</li>
--   </ul>
type ListBoxMoveCursorCallback = MovementStep -> Int32 -> Bool -> Bool -> IO ()

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #moveCursor callback
--   </pre>
onListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxMoveCursorCallback) -> m SignalHandlerId

-- | Emitted when a row has been activated by the user.
type ListBoxRowActivatedCallback = ListBoxRow -> IO ()

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #rowActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowActivated</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #rowActivated callback
--   </pre>
onListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowActivatedCallback) -> m SignalHandlerId

-- | Emitted when a new row is selected, or (with a <a>Nothing</a>
--   <i><tt>row</tt></i>) when the selection is cleared.
--   
--   When the <i><tt>box</tt></i> is using <a>SelectionModeMultiple</a>,
--   this signal will not give you the full picture of selection changes,
--   and you should use the <a>ListBox::selectedRowsChanged</a> signal
--   instead.
type ListBoxRowSelectedCallback = Maybe ListBoxRow -> IO ()

-- | Connect a signal handler for the <a>rowSelected</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #rowSelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowSelected</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #rowSelected callback
--   </pre>
onListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxRowSelectedCallback) -> m SignalHandlerId

-- | Emitted to select all children of the box, if the selection mode
--   permits it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
type ListBoxSelectAllCallback = IO ()

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #selectAll callback
--   </pre>
onListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectAllCallback) -> m SignalHandlerId

-- | Emitted when the set of selected rows changes.
type ListBoxSelectedRowsChangedCallback = IO ()

-- | Connect a signal handler for the <a>selectedRowsChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> listBox #selectedRowsChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectedRowsChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectedRowsChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #selectedRowsChanged callback
--   </pre>
onListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxSelectedRowsChangedCallback) -> m SignalHandlerId

-- | Emitted when the cursor row is toggled.
--   
--   The default bindings for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;␣&lt;/kbd&gt;.
type ListBoxToggleCursorRowCallback = IO ()

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> listBox #toggleCursorRow callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxToggleCursorRowCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorRow</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #toggleCursorRow callback
--   </pre>
onListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxToggleCursorRowCallback) -> m SignalHandlerId

-- | Emitted to unselect all children of the box, if the selection mode
--   permits it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
type ListBoxUnselectAllCallback = IO ()

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> listBox #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> listBox #unselectAll callback
--   </pre>
onListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ((?self :: a) => ListBoxUnselectAllCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ListBox.ListBox
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListBox.ListBox
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListBox.ListBox
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListBox.ListBox)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListBox.ListBox o) => GI.Gtk.Objects.ListBox.IsListBox o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListBox.ListBox
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListBox.ListBox


-- | The abstract base class for GTK's list widgets.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkListBase</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;A&lt;/kbd&gt; or
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;&amp;sol;&lt;/kbd&gt; selects
--   all items.</li>
--   
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;A&lt;/kbd&gt;
--   or &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;&amp;bsol;&lt;/kbd&gt;
--   unselects all items.</li>
--   </ul>
--   
--   The focused item is controlled by the navigation keys below, combined
--   with the &lt;kbd&gt;Ctrl&lt;/kbd&gt; modifier to prevent moving the
--   selection, and the &lt;kbd&gt;Shift&lt;/kbd&gt; modifier to extend the
--   current selection.
--   
--   <ul>
--   <li>&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;↑&lt;/kbd&gt;, &lt;kbd&gt;↓&lt;/kbd&gt; move the focus on
--   the next item in the designed direction.</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt; and &lt;kbd&gt;End&lt;/kbd&gt; focus
--   the first or last item.</li>
--   <li>&lt;kbd&gt;PgUp&lt;/kbd&gt; and &lt;kbd&gt;PgDn&lt;/kbd&gt; move
--   the focus one page up or down.</li>
--   </ul>
--   
--   List item widgets support the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Enter&lt;/kbd&gt; activates the item.</li>
--   <li>&lt;kbd&gt;␣&lt;/kbd&gt; selects the item, with the same
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt; and &lt;kbd&gt;Shift&lt;/kbd&gt; modifiers
--   combinations as the navigation keys.</li>
--   </ul>
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkListBase</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>list.scroll-to-item</tt> moves the visible area to the item at
--   given position with the minimum amount of scrolling required. If the
--   item is already visible, nothing happens.</li>
--   <li><tt>list.select-item</tt> changes the selection.</li>
--   <li><tt>list.select-all</tt> selects all items in the model, if the
--   selection model supports it.</li>
--   <li><tt>list.unselect-all</tt> unselects all items in the model, if
--   the selection model supports it.</li>
--   </ul>
--   
--   List item widgets install the following actions:
--   
--   <ul>
--   <li><tt>listitem.select</tt> changes selection if the item is
--   selectable.</li>
--   <li><tt>listitem.scroll-to</tt> moves the visible area of the list to
--   this item with the minimum amount of scrolling required.</li>
--   </ul>
module GI.Gtk.Objects.ListBase

-- | Memory-managed wrapper type.
newtype ListBase
ListBase :: ManagedPtr ListBase -> ListBase

-- | Type class for types which can be safely cast to <a>ListBase</a>, for
--   instance with <a>toListBase</a>.
class (GObject o, IsDescendantOf ListBase o) => IsListBase o

-- | Cast to <a>ListBase</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toListBase :: (MonadIO m, IsListBase o) => o -> m ListBase

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>orientation</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructListBaseOrientation :: (IsListBase o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Get the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> listBase #orientation
--   </pre>
getListBaseOrientation :: (MonadIO m, IsListBase o) => o -> m Orientation

-- | Set the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> listBase [ #orientation <a>:=</a> value ]
--   </pre>
setListBaseOrientation :: (MonadIO m, IsListBase o) => o -> Orientation -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ListBase.ListBase
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ListBase.ListBase
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ListBase.ListBase
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ListBase.ListBase)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ListBase.ListBase o) => GI.Gtk.Objects.ListBase.IsListBase o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ListBase.ListBase
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ListBase.ListBase


-- | A button with a hyperlink.
--   
--   &lt;picture&gt; &lt;source srcset="link-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkLinkButton" src="link-button.png"&gt; &lt;/picture&gt;
--   
--   It is useful to show quick links to resources.
--   
--   A link button is created by calling either <a>linkButtonNew</a> or
--   <a>linkButtonNewWithLabel</a>. If using the former, the URI you pass
--   to the constructor is used as a label for the widget.
--   
--   The URI bound to a <tt>GtkLinkButton</tt> can be set specifically
--   using <a>linkButtonSetUri</a>.
--   
--   By default, <tt>GtkLinkButton</tt> calls <a>fileLauncherLaunch</a>
--   when the button is clicked. This behaviour can be overridden by
--   connecting to the <a>LinkButton::activateLink</a> signal and returning
--   <a>True</a> from the signal handler.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkLinkButton</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;F10&lt;/kbd&gt; or
--   &lt;kbd&gt;Menu&lt;/kbd&gt; opens the context menu.</li>
--   </ul>
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkLinkButton</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>clipboard.copy</tt> copies the url to the clipboard.</li>
--   <li><tt>menu.popup</tt> opens the context menu.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkLinkButton</tt> has a single CSS node with name button. To
--   differentiate it from a plain <tt>GtkButton</tt>, it gets the .link
--   style class.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkLinkButton</tt> uses the <a>AccessibleRoleLink</a> role.
module GI.Gtk.Objects.LinkButton

-- | Memory-managed wrapper type.
newtype LinkButton
LinkButton :: ManagedPtr LinkButton -> LinkButton

-- | Type class for types which can be safely cast to <a>LinkButton</a>,
--   for instance with <a>toLinkButton</a>.
class (GObject o, IsDescendantOf LinkButton o) => IsLinkButton o

-- | Cast to <a>LinkButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toLinkButton :: (MonadIO m, IsLinkButton o) => o -> m LinkButton

-- | Retrieves the URI of the <tt>GtkLinkButton</tt>.
linkButtonGetUri :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> m Text

-- | Retrieves the “visited” state of the <tt>GtkLinkButton</tt>.
--   
--   The button becomes visited when it is clicked. If the URI is changed
--   on the button, the “visited” state is unset again.
--   
--   The state may also be changed using <a>linkButtonSetVisited</a>.
linkButtonGetVisited :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> m Bool

-- | Creates a new <tt>GtkLinkButton</tt> with the URI as its text.
linkButtonNew :: (HasCallStack, MonadIO m) => Text -> m LinkButton

-- | Creates a new <tt>GtkLinkButton</tt> containing a label.
linkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> m LinkButton

-- | Sets <i><tt>uri</tt></i> as the URI where the <tt>GtkLinkButton</tt>
--   points.
--   
--   As a side-effect this unsets the “visited” state of the button.
linkButtonSetUri :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> Text -> m ()

-- | Sets the “visited” state of the <tt>GtkLinkButton</tt>.
--   
--   See <a>linkButtonGetVisited</a> for more details.
linkButtonSetVisited :: (HasCallStack, MonadIO m, IsLinkButton a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>uri</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLinkButtonUri :: (IsLinkButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>uri</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> linkButton #uri
--   </pre>
getLinkButtonUri :: (MonadIO m, IsLinkButton o) => o -> m Text

-- | Set the value of the “<tt>uri</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> linkButton [ #uri <a>:=</a> value ]
--   </pre>
setLinkButtonUri :: (MonadIO m, IsLinkButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visited</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLinkButtonVisited :: (IsLinkButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visited</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> linkButton #visited
--   </pre>
getLinkButtonVisited :: (MonadIO m, IsLinkButton o) => o -> m Bool

-- | Set the value of the “<tt>visited</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> linkButton [ #visited <a>:=</a> value ]
--   </pre>
setLinkButtonVisited :: (MonadIO m, IsLinkButton o) => o -> Bool -> m ()

-- | Emitted each time the <tt>GtkLinkButton</tt> is clicked.
--   
--   The default handler will call <a>fileLauncherLaunch</a> with the URI
--   stored inside the <a>LinkButton:uri</a> property.
--   
--   To override the default behavior, you can connect to the
--   <a>activateLink</a> signal and stop the propagation of the signal by
--   returning <a>True</a> from your handler.
type LinkButtonActivateLinkCallback = IO Bool

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> linkButton #activateLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLinkButtonActivateLink :: (IsLinkButton a, MonadIO m) => a -> ((?self :: a) => LinkButtonActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> linkButton #activateLink callback
--   </pre>
onLinkButtonActivateLink :: (IsLinkButton a, MonadIO m) => a -> ((?self :: a) => LinkButtonActivateLinkCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.LinkButton.LinkButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.LinkButton.LinkButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.LinkButton.LinkButton
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.LinkButton.LinkButton)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.LinkButton.LinkButton o) => GI.Gtk.Objects.LinkButton.IsLinkButton o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.LinkButton.LinkButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.LinkButton.LinkButton


-- | Shows a level indicator.
--   
--   Typical use cases are displaying the strength of a password, or
--   showing the charge level of a battery.
--   
--   &lt;picture&gt; &lt;source srcset="levelbar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkLevelBar" src="levelbar.png"&gt; &lt;/picture&gt;
--   
--   Use <a>levelBarSetValue</a> to set the current value, and
--   <a>levelBarAddOffsetValue</a> to set the value offsets at which the
--   bar will be considered in a different state. GTK will add a few
--   offsets by default on the level bar: <a>LEVEL_BAR_OFFSET_LOW</a>,
--   <a>LEVEL_BAR_OFFSET_HIGH</a> and <a>LEVEL_BAR_OFFSET_FULL</a>, with
--   values 0.25, 0.75 and 1.0 respectively.
--   
--   Note that it is your responsibility to update preexisting offsets when
--   changing the minimum or maximum value. GTK will simply clamp them to
--   the new range.
--   
--   <h2>Adding a custom offset on the bar</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static GtkWidget *
--   create_level_bar (void)
--   {
--     GtkWidget *widget;
--     GtkLevelBar *bar;
--   
--     widget = gtk_level_bar_new ();
--     bar = GTK_LEVEL_BAR (widget);
--   
--     // This changes the value of the default low offset
--   
--     gtk_level_bar_add_offset_value (bar,
--                                     GTK_LEVEL_BAR_OFFSET_LOW,
--                                     0.10);
--   
--     // This adds a new offset to the bar; the application will
--     // be able to change its color CSS like this:
--     //
--     // levelbar block.my-offset {
--     //   background-color: magenta;
--     //   border-style: solid;
--     //   border-color: black;
--     //   border-width: 1px;
--     // }
--   
--     gtk_level_bar_add_offset_value (bar, "my-offset", 0.60);
--   
--     return widget;
--   }
--   </pre>
--   
--   The default interval of values is between zero and one, but it’s
--   possible to modify the interval using <a>levelBarSetMinValue</a> and
--   <a>levelBarSetMaxValue</a>. The value will be always drawn in
--   proportion to the admissible interval, i.e. a value of 15 with a
--   specified interval between 10 and 20 is equivalent to a value of 0.5
--   with an interval between 0 and 1. When <a>LevelBarModeDiscrete</a> is
--   used, the bar level is rendered as a finite number of separated blocks
--   instead of a single one. The number of blocks that will be rendered is
--   equal to the number of units specified by the admissible interval.
--   
--   For instance, to build a bar rendered with five blocks, it’s
--   sufficient to set the minimum value to 0 and the maximum value to 5
--   after changing the indicator mode to discrete.
--   
--   <h1>GtkLevelBar as GtkBuildable</h1>
--   
--   The <tt>GtkLevelBar</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports a custom <tt>&lt;offsets&gt;</tt> element, which
--   can contain any number of <tt>&lt;offset&gt;</tt> elements, each of
--   which must have "name" and "value" attributes.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   levelbar[.discrete]
--   ╰── trough
--       ├── block.filled.level-name
--       ┊
--       ├── block.empty
--       ┊
--   </pre>
--   
--   <tt>GtkLevelBar</tt> has a main CSS node with name levelbar and one of
--   the style classes .discrete or .continuous and a subnode with name
--   trough. Below the trough node are a number of nodes with name block
--   and style class .filled or .empty. In continuous mode, there is
--   exactly one node of each, in discrete mode, the number of filled and
--   unfilled nodes corresponds to blocks that are drawn. The block.filled
--   nodes also get a style class .level-name corresponding to the level
--   for the current value.
--   
--   In horizontal orientation, the nodes are always arranged from left to
--   right, regardless of text direction.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkLevelBar</tt> uses the <a>AccessibleRoleMeter</a> role.
module GI.Gtk.Objects.LevelBar

-- | Memory-managed wrapper type.
newtype LevelBar
LevelBar :: ManagedPtr LevelBar -> LevelBar

-- | Type class for types which can be safely cast to <a>LevelBar</a>, for
--   instance with <a>toLevelBar</a>.
class (GObject o, IsDescendantOf LevelBar o) => IsLevelBar o

-- | Cast to <a>LevelBar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toLevelBar :: (MonadIO m, IsLevelBar o) => o -> m LevelBar

-- | Adds a new offset marker on <i><tt>self</tt></i> at the position
--   specified by <i><tt>value</tt></i>.
--   
--   When the bar value is in the interval topped by <i><tt>value</tt></i>
--   (or between <i><tt>value</tt></i> and <a>LevelBar:maxValue</a> in case
--   the offset is the last one on the bar) a style class named
--   <tt>level-</tt><i><tt>name</tt></i> will be applied when rendering the
--   level bar fill.
--   
--   If another offset marker named <i><tt>name</tt></i> exists, its value
--   will be replaced by <i><tt>value</tt></i>.
levelBarAddOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Text -> Double -> m ()

-- | Returns whether the levelbar is inverted.
levelBarGetInverted :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Bool

-- | Returns the <tt>max-value</tt> of the <tt>GtkLevelBar</tt>.
levelBarGetMaxValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Returns the <tt>min-value</tt> of the <tt>GtkLevelBar</tt>.
levelBarGetMinValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Returns the <tt>mode</tt> of the <tt>GtkLevelBar</tt>.
levelBarGetMode :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m LevelBarMode

-- | Fetches the value specified for the offset marker <i><tt>name</tt></i>
--   in <i><tt>self</tt></i>.
levelBarGetOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m (Bool, Double)

-- | Returns the <tt>value</tt> of the <tt>GtkLevelBar</tt>.
levelBarGetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> m Double

-- | Creates a new <tt>GtkLevelBar</tt>.
levelBarNew :: (HasCallStack, MonadIO m) => m LevelBar

-- | Creates a new <tt>GtkLevelBar</tt> for the specified interval.
levelBarNewForInterval :: (HasCallStack, MonadIO m) => Double -> Double -> m LevelBar

-- | Removes an offset marker from a <tt>GtkLevelBar</tt>.
--   
--   The marker must have been previously added with
--   <a>levelBarAddOffsetValue</a>.
levelBarRemoveOffsetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Maybe Text -> m ()

-- | Sets whether the <tt>GtkLevelBar</tt> is inverted.
levelBarSetInverted :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Bool -> m ()

-- | Sets the <tt>max-value</tt> of the <tt>GtkLevelBar</tt>.
--   
--   You probably want to update preexisting level offsets after calling
--   this function.
levelBarSetMaxValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Sets the <tt>min-value</tt> of the <tt>GtkLevelBar</tt>.
--   
--   You probably want to update preexisting level offsets after calling
--   this function.
levelBarSetMinValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Sets the <tt>mode</tt> of the <tt>GtkLevelBar</tt>.
levelBarSetMode :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> LevelBarMode -> m ()

-- | Sets the value of the <tt>GtkLevelBar</tt>.
levelBarSetValue :: (HasCallStack, MonadIO m, IsLevelBar a) => a -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLevelBarInverted :: (IsLevelBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #inverted
--   </pre>
getLevelBarInverted :: (MonadIO m, IsLevelBar o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #inverted <a>:=</a> value ]
--   </pre>
setLevelBarInverted :: (MonadIO m, IsLevelBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-value</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLevelBarMaxValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #maxValue
--   </pre>
getLevelBarMaxValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “<tt>max-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #maxValue <a>:=</a> value ]
--   </pre>
setLevelBarMaxValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-value</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLevelBarMinValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #minValue
--   </pre>
getLevelBarMinValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “<tt>min-value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #minValue <a>:=</a> value ]
--   </pre>
setLevelBarMinValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLevelBarMode :: (IsLevelBar o, MonadIO m) => LevelBarMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #mode
--   </pre>
getLevelBarMode :: (MonadIO m, IsLevelBar o) => o -> m LevelBarMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #mode <a>:=</a> value ]
--   </pre>
setLevelBarMode :: (MonadIO m, IsLevelBar o) => o -> LevelBarMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLevelBarValue :: (IsLevelBar o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> levelBar #value
--   </pre>
getLevelBarValue :: (MonadIO m, IsLevelBar o) => o -> m Double

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> levelBar [ #value <a>:=</a> value ]
--   </pre>
setLevelBarValue :: (MonadIO m, IsLevelBar o) => o -> Double -> m ()

-- | Emitted when an offset specified on the bar changes value.
--   
--   This typically is the result of a <a>levelBarAddOffsetValue</a> call.
--   
--   The signal supports detailed connections; you can connect to the
--   detailed signal "changed<a>x</a>" in order to only receive callbacks
--   when the value of offset "x" changes.
type LevelBarOffsetChangedCallback = Text -> IO ()

-- | Connect a signal handler for the <a>offsetChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> levelBar #offsetChanged callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>offset-changed::detail</tt>”
--   instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLevelBarOffsetChanged :: (IsLevelBar a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => LevelBarOffsetChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>offsetChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> levelBar #offsetChanged callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>offset-changed::detail</tt>”
--   instead.
onLevelBarOffsetChanged :: (IsLevelBar a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => LevelBarOffsetChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.LevelBar.LevelBar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.LevelBar.LevelBar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.LevelBar.LevelBar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.LevelBar.LevelBar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.LevelBar.LevelBar o) => GI.Gtk.Objects.LevelBar.IsLevelBar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.LevelBar.LevelBar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.LevelBar.LevelBar


-- | Handles the preferred size and allocation for children of a widget.
--   
--   You typically subclass <tt>GtkLayoutManager</tt> if you want to
--   implement a layout policy for the children of a widget, or if you want
--   to determine the size of a widget depending on its contents.
--   
--   Each <tt>GtkWidget</tt> can only have a <tt>GtkLayoutManager</tt>
--   instance associated to it at any given time; it is possible, though,
--   to replace the layout manager instance using
--   <a>widgetSetLayoutManager</a>.
--   
--   <h2>Layout properties</h2>
--   
--   A layout manager can expose properties for controlling the layout of
--   each child, by creating an object type derived from <a>LayoutChild</a>
--   and installing the properties on it as normal <tt>GObject</tt>
--   properties.
--   
--   Each <tt>GtkLayoutChild</tt> instance storing the layout properties
--   for a specific child is created through the
--   <a>layoutManagerGetLayoutChild</a> method; a <tt>GtkLayoutManager</tt>
--   controls the creation of its <tt>GtkLayoutChild</tt> instances by
--   overriding the
--   GtkLayoutManagerClass.<tt><i>create_layout_child()</i></tt> virtual
--   function. The typical implementation should look like:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static GtkLayoutChild *
--   create_layout_child (GtkLayoutManager *manager,
--                        GtkWidget        *container,
--                        GtkWidget        *child)
--   {
--     return g_object_new (your_layout_child_get_type (),
--                          "layout-manager", manager,
--                          "child-widget", child,
--                          NULL);
--   }
--   </pre>
--   
--   The <a>LayoutChild:layoutManager</a> and
--   <a>LayoutChild:childWidget</a> properties on the newly created
--   <tt>GtkLayoutChild</tt> instance are mandatory. The
--   <tt>GtkLayoutManager</tt> will cache the newly created
--   <tt>GtkLayoutChild</tt> instance until the widget is removed from its
--   parent, or the parent removes the layout manager.
--   
--   Each <tt>GtkLayoutManager</tt> instance creating a
--   <tt>GtkLayoutChild</tt> should use <a>layoutManagerGetLayoutChild</a>
--   every time it needs to query the layout properties; each
--   <tt>GtkLayoutChild</tt> instance should call
--   <a>layoutManagerLayoutChanged</a> every time a property is updated, in
--   order to queue a new size measuring and allocation.
module GI.Gtk.Objects.LayoutManager

-- | Memory-managed wrapper type.
newtype LayoutManager
LayoutManager :: ManagedPtr LayoutManager -> LayoutManager

-- | Type class for types which can be safely cast to <a>LayoutManager</a>,
--   for instance with <a>toLayoutManager</a>.
class (GObject o, IsDescendantOf LayoutManager o) => IsLayoutManager o

-- | Cast to <a>LayoutManager</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toLayoutManager :: (MonadIO m, IsLayoutManager o) => o -> m LayoutManager

-- | Assigns the given <i><tt>width</tt></i>, <i><tt>height</tt></i>, and
--   <i><tt>baseline</tt></i> to a <i><tt>widget</tt></i>, and computes the
--   position and sizes of the children of the <i><tt>widget</tt></i> using
--   the layout management policy of <i><tt>manager</tt></i>.
layoutManagerAllocate :: (HasCallStack, MonadIO m, IsLayoutManager a, IsWidget b) => a -> b -> Int32 -> Int32 -> Int32 -> m ()

-- | Retrieves a <tt>GtkLayoutChild</tt> instance for the
--   <tt>GtkLayoutManager</tt>, creating one if necessary.
--   
--   The <i><tt>child</tt></i> widget must be a child of the widget using
--   <i><tt>manager</tt></i>.
--   
--   The <tt>GtkLayoutChild</tt> instance is owned by the
--   <tt>GtkLayoutManager</tt>, and is guaranteed to exist as long as
--   <i><tt>child</tt></i> is a child of the <tt>GtkWidget</tt> using the
--   given <tt>GtkLayoutManager</tt>.
layoutManagerGetLayoutChild :: (HasCallStack, MonadIO m, IsLayoutManager a, IsWidget b) => a -> b -> m LayoutChild

-- | Retrieves the request mode of <i><tt>manager</tt></i>.
layoutManagerGetRequestMode :: (HasCallStack, MonadIO m, IsLayoutManager a) => a -> m SizeRequestMode

-- | Retrieves the <tt>GtkWidget</tt> using the given
--   <tt>GtkLayoutManager</tt>.
layoutManagerGetWidget :: (HasCallStack, MonadIO m, IsLayoutManager a) => a -> m (Maybe Widget)

-- | Queues a resize on the <tt>GtkWidget</tt> using
--   <i><tt>manager</tt></i>, if any.
--   
--   This function should be called by subclasses of
--   <tt>GtkLayoutManager</tt> in response to changes to their layout
--   management policies.
layoutManagerLayoutChanged :: (HasCallStack, MonadIO m, IsLayoutManager a) => a -> m ()

-- | Measures the size of the <i><tt>widget</tt></i> using
--   <i><tt>manager</tt></i>, for the given <i><tt>orientation</tt></i> and
--   size.
--   
--   See the <a>Widget</a> documentation on layout management for more
--   details.
layoutManagerMeasure :: (HasCallStack, MonadIO m, IsLayoutManager a, IsWidget b) => a -> b -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)
instance GHC.Classes.Eq GI.Gtk.Objects.LayoutManager.LayoutManager
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.LayoutManager.LayoutManager
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.LayoutManager.LayoutManager
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.LayoutManager.LayoutManager)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.LayoutManager.LayoutManager o) => GI.Gtk.Objects.LayoutManager.IsLayoutManager o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.LayoutManager.LayoutManager
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.LayoutManager.LayoutManager


-- | The base class for objects that are meant to hold layout properties.
--   
--   If a <tt>GtkLayoutManager</tt> has per-child properties, like their
--   packing type, or the horizontal and vertical span, or the icon name,
--   then the layout manager should use a <tt>GtkLayoutChild</tt>
--   implementation to store those properties.
--   
--   A <tt>GtkLayoutChild</tt> instance is only ever valid while a widget
--   is part of a layout.
module GI.Gtk.Objects.LayoutChild

-- | Memory-managed wrapper type.
newtype LayoutChild
LayoutChild :: ManagedPtr LayoutChild -> LayoutChild

-- | Type class for types which can be safely cast to <a>LayoutChild</a>,
--   for instance with <a>toLayoutChild</a>.
class (GObject o, IsDescendantOf LayoutChild o) => IsLayoutChild o

-- | Cast to <a>LayoutChild</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toLayoutChild :: (MonadIO m, IsLayoutChild o) => o -> m LayoutChild

-- | Retrieves the <tt>GtkWidget</tt> associated to the given
--   <i><tt>layoutChild</tt></i>.
layoutChildGetChildWidget :: (HasCallStack, MonadIO m, IsLayoutChild a) => a -> m Widget

-- | Retrieves the <tt>GtkLayoutManager</tt> instance that created the
--   given <i><tt>layoutChild</tt></i>.
layoutChildGetLayoutManager :: (HasCallStack, MonadIO m, IsLayoutChild a) => a -> m LayoutManager

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLayoutChildChildWidget :: (IsLayoutChild o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutChild #childWidget
--   </pre>
getLayoutChildChildWidget :: (MonadIO m, IsLayoutChild o) => o -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>layout-manager</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLayoutChildLayoutManager :: (IsLayoutChild o, MonadIO m, IsLayoutManager a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>layout-manager</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutChild #layoutManager
--   </pre>
getLayoutChildLayoutManager :: (MonadIO m, IsLayoutChild o) => o -> m LayoutManager
instance GHC.Classes.Eq GI.Gtk.Objects.LayoutChild.LayoutChild
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.LayoutChild.LayoutChild
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.LayoutChild.LayoutChild
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.LayoutChild.LayoutChild)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.LayoutChild.LayoutChild o) => GI.Gtk.Objects.LayoutChild.IsLayoutChild o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.LayoutChild.LayoutChild
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.LayoutChild.LayoutChild


-- | Displays a small amount of text.
--   
--   Most labels are used to label another widget (such as an
--   [class<i><tt>entry</tt></i>]).
--   
--   &lt;picture&gt; &lt;source srcset="label-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkLabel" src="label.png"&gt; &lt;/picture&gt;
--   
--   <h2>Shortcuts and Gestures</h2>
--   
--   <tt>GtkLabel</tt> supports the following keyboard shortcuts, when the
--   cursor is visible:
--   
--   <ul>
--   <li>&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;F10&lt;/kbd&gt; or
--   &lt;kbd&gt;Menu&lt;/kbd&gt; opens the context menu.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;A&lt;/kbd&gt; or
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;&amp;sol;&lt;/kbd&gt; selects
--   all.</li>
--   
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;A&lt;/kbd&gt;
--   or &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;&amp;bsol;&lt;/kbd&gt;
--   unselects all.</li>
--   </ul>
--   
--   Additionally, the following signals have default keybindings:
--   
--   <ul>
--   <li><a>Label::activateCurrentLink</a></li>
--   <li><a>Label::copyClipboard</a></li>
--   <li><a>Label::moveCursor</a></li>
--   </ul>
--   
--   <h2>Actions</h2>
--   
--   <tt>GtkLabel</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>clipboard.copy</tt> copies the text to the clipboard.</li>
--   <li><tt>clipboard.cut</tt> doesn't do anything, since text in labels
--   can't be deleted.</li>
--   <li><tt>clipboard.paste</tt> doesn't do anything, since text in labels
--   can't be edited.</li>
--   <li><tt>link.open</tt> opens the link, when activated on a link inside
--   the label.</li>
--   <li><tt>link.copy</tt> copies the link to the clipboard, when
--   activated on a link inside the label.</li>
--   <li><tt>menu.popup</tt> opens the context menu.</li>
--   <li><tt>selection.delete</tt> doesn't do anything, since text in
--   labels can't be deleted.</li>
--   <li><tt>selection.select-all</tt> selects all of the text, if the
--   label allows selection.</li>
--   </ul>
--   
--   <h2>CSS nodes</h2>
--   
--   <pre>
--   label
--   ├── [selection]
--   ├── [link]
--   ┊
--   ╰── [link]
--   </pre>
--   
--   <tt>GtkLabel</tt> has a single CSS node with the name label. A wide
--   variety of style classes may be applied to labels, such as .title,
--   .subtitle, .dim-label, etc. In the <tt>GtkShortcutsWindow</tt>, labels
--   are used with the .keycap style class.
--   
--   If the label has a selection, it gets a subnode with name selection.
--   
--   If the label has links, there is one subnode per link. These subnodes
--   carry the link or visited state depending on whether they have been
--   visited. In this case, label node also gets a .link style class.
--   
--   <h2>GtkLabel as GtkBuildable</h2>
--   
--   The GtkLabel implementation of the GtkBuildable interface supports a
--   custom <tt>&lt;attributes&gt;</tt> element, which supports any number
--   of <tt>&lt;attribute&gt;</tt> elements. The <tt>&lt;attribute&gt;</tt>
--   element has attributes named “name“, “value“, “start“ and “end“ and
--   allows you to specify <a>Attribute</a> values for this label.
--   
--   An example of a UI definition fragment specifying Pango attributes:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkLabel"&gt;
--     &lt;attributes&gt;
--       &lt;attribute name="weight" value="PANGO_WEIGHT_BOLD"/&gt;
--       &lt;attribute name="background" value="red" start="5" end="10"/&gt;
--     &lt;/attributes&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   The start and end attributes specify the range of characters to which
--   the Pango attribute applies. If start and end are not specified, the
--   attribute is applied to the whole text. Note that specifying ranges
--   does not make much sense with translatable attributes. Use markup
--   embedded in the translatable content instead.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkLabel</tt> uses the <a>AccessibleRoleLabel</a> role.
--   
--   <h2>Mnemonics</h2>
--   
--   Labels may contain “mnemonics”. Mnemonics are underlined characters in
--   the label, used for keyboard navigation. Mnemonics are created by
--   providing a string with an underscore before the mnemonic character,
--   such as <tt>"_File"</tt>, to the functions <a>labelNewWithMnemonic</a>
--   or <a>labelSetTextWithMnemonic</a>.
--   
--   Mnemonics automatically activate any activatable widget the label is
--   inside, such as a <a>Button</a>; if the label is not inside the
--   mnemonic’s target widget, you have to tell the label about the target
--   using <a>labelSetMnemonicWidget</a>.
--   
--   Here’s a simple example where the label is inside a button:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // Pressing Alt+H will activate this button
--   GtkWidget *button = gtk_button_new ();
--   GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
--   gtk_button_set_child (GTK_BUTTON (button), label);
--   </pre>
--   
--   There’s a convenience function to create buttons with a mnemonic label
--   already inside:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // Pressing Alt+H will activate this button
--   GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");
--   </pre>
--   
--   To create a mnemonic for a widget alongside the label, such as a
--   <a>Entry</a>, you have to point the label at the entry with
--   <a>labelSetMnemonicWidget</a>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // Pressing Alt+H will focus the entry
--   GtkWidget *entry = gtk_entry_new ();
--   GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
--   gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
--   </pre>
--   
--   <h2>Markup (styled text)</h2>
--   
--   To make it easy to format text in a label (changing colors, fonts,
--   etc.), label text can be provided in a simple markup format:
--   
--   Here’s how to create a label with a small font:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *label = gtk_label_new (NULL);
--   gtk_label_set_markup (GTK_LABEL (label), "&lt;small&gt;Small text&lt;/small&gt;");
--   </pre>
--   
--   (See the Pango manual for complete documentation] of available tags,
--   <a>parseMarkup</a>)
--   
--   The markup passed to <a>labelSetMarkup</a> must be valid XML; for
--   example, literal <tt>&lt;</tt>, <tt>&gt;</tt> and <tt>&amp;</tt>
--   characters must be escaped as <tt>&amp;lt;</tt>, <tt>&amp;gt;</tt>,
--   and <tt>&amp;amp;</tt>. If you pass text obtained from the user, file,
--   or a network to <a>labelSetMarkup</a>, you’ll want to escape it with
--   <a>markupEscapeText</a> or <tt><i>GLib.markup_printf_escaped</i></tt>.
--   
--   Markup strings are just a convenient way to set the <a>AttrList</a> on
--   a label; <a>labelSetAttributes</a> may be a simpler way to set
--   attributes in some cases. Be careful though; <a>AttrList</a> tends to
--   cause internationalization problems, unless you’re applying attributes
--   to the entire string (i.e. unless you set the range of each attribute
--   to [0, <tt>G_MAXINT</tt>)). The reason is that specifying the
--   <tt>start_index</tt> and <tt>end_index</tt> for a <a>Attribute</a>
--   requires knowledge of the exact string being displayed, so
--   translations will cause problems.
--   
--   <h2>Selectable labels</h2>
--   
--   Labels can be made selectable with <a>labelSetSelectable</a>.
--   Selectable labels allow the user to copy the label contents to the
--   clipboard. Only labels that contain useful-to-copy information — such
--   as error messages — should be made selectable.
--   
--   <h2>Text layout</h2>
--   
--   A label can contain any number of paragraphs, but will have
--   performance problems if it contains more than a small number.
--   Paragraphs are separated by newlines or other paragraph separators
--   understood by Pango.
--   
--   Labels can automatically wrap text if you call <a>labelSetWrap</a>.
--   
--   <a>labelSetJustify</a> sets how the lines in a label align with one
--   another. If you want to set how the label as a whole aligns in its
--   available space, see the <a>Widget:halign</a> and <a>Widget:valign</a>
--   properties.
--   
--   The <a>Label:widthChars</a> and <a>Label:maxWidthChars</a> properties
--   can be used to control the size allocation of ellipsized or wrapped
--   labels. For ellipsizing labels, if either is specified (and less than
--   the actual text size), it is used as the minimum width, and the actual
--   text size is used as the natural width of the label. For wrapping
--   labels, width-chars is used as the minimum width, if specified, and
--   max-width-chars is used as the natural width. Even if max-width-chars
--   specified, wrapping labels will be rewrapped to use all of the
--   available width.
--   
--   <h2>Links</h2>
--   
--   GTK supports markup for clickable hyperlinks in addition to regular
--   Pango markup. The markup for links is borrowed from HTML, using the
--   <tt>&lt;a&gt;</tt> tag with “href“, “title“ and “class“ attributes.
--   GTK renders links similar to the way they appear in web browsers, with
--   colored, underlined text. The “title“ attribute is displayed as a
--   tooltip on the link. The “class“ attribute is used as style class on
--   the CSS node for the link.
--   
--   An example of inline links looks like this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   const char *text =
--   "Go to the "
--   "&lt;a href=\"https://www.gtk.org\" title=\"&amp;lt;i&amp;gt;Our&amp;lt;/i&amp;gt; website\"&gt;"
--   "GTK website&lt;/a&gt; for more...";
--   GtkWidget *label = gtk_label_new (NULL);
--   gtk_label_set_markup (GTK_LABEL (label), text);
--   </pre>
--   
--   It is possible to implement custom handling for links and their
--   tooltips with the <a>Label::activateLink</a> signal and the
--   <a>labelGetCurrentUri</a> function.
module GI.Gtk.Objects.Label

-- | Memory-managed wrapper type.
newtype Label
Label :: ManagedPtr Label -> Label

-- | Type class for types which can be safely cast to <a>Label</a>, for
--   instance with <a>toLabel</a>.
class (GObject o, IsDescendantOf Label o) => IsLabel o

-- | Cast to <a>Label</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toLabel :: (MonadIO m, IsLabel o) => o -> m Label

-- | Gets the label's attribute list.
--   
--   This is the <a>AttrList</a> that was set on the label using
--   <a>labelSetAttributes</a>, if any. This function does not reflect
--   attributes that come from the label's markup (see
--   <a>labelSetMarkup</a>). If you want to get the effective attributes
--   for the label, use <tt>pango_layout_get_attributes
--   (gtk_label_get_layout (self))</tt>.
labelGetAttributes :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe AttrList)

-- | Returns the URI for the active link in the label.
--   
--   The active link is the one under the mouse pointer or, in a selectable
--   label, the link in which the text cursor is currently positioned.
--   
--   This function is intended for use in a <a>Label::activateLink</a>
--   handler or for use in a <a>Widget::queryTooltip</a> handler.
labelGetCurrentUri :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe Text)

-- | Returns the ellipsization mode of the label.
--   
--   See <a>labelSetEllipsize</a>.
labelGetEllipsize :: (HasCallStack, MonadIO m, IsLabel a) => a -> m EllipsizeMode

-- | Gets the extra menu model of the label.
--   
--   See <a>labelSetExtraMenu</a>.
labelGetExtraMenu :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe MenuModel)

-- | Returns the justification of the label.
--   
--   See <a>labelSetJustify</a>.
labelGetJustify :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Justification

-- | Fetches the text from a label.
--   
--   The returned text includes any embedded underlines indicating
--   mnemonics and Pango markup. (See <a>labelGetText</a>).
labelGetLabel :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | Gets the Pango layout used to display the label.
--   
--   The layout is useful to e.g. convert text positions to pixel
--   positions, in combination with <a>labelGetLayoutOffsets</a>. The
--   returned layout is owned by the <i><tt>label</tt></i> so need not be
--   freed by the caller. The <i><tt>label</tt></i> is free to recreate its
--   layout at any time, so it should be considered read-only.
labelGetLayout :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Layout

-- | Obtains the coordinates where the label will draw its Pango layout.
--   
--   The coordinates are useful to convert mouse events into coordinates
--   inside the <a>Layout</a>, e.g. to take some action if some part of the
--   label is clicked. Remember when using the <a>Layout</a> functions you
--   need to convert to and from pixels using <tt>PANGO_PIXELS()</tt> or
--   [const<i><tt>pango</tt></i>.SCALE].
labelGetLayoutOffsets :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Int32, Int32)

-- | Gets the number of lines to which an ellipsized, wrapping label should
--   be limited.
--   
--   See <a>labelSetLines</a>.
labelGetLines :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | Retrieves the maximum width of the label in characters.
--   
--   See <a>labelSetWidthChars</a>.
labelGetMaxWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | Return the mnemonic accelerator.
--   
--   If the label has been set so that it has a mnemonic key this function
--   returns the keyval used for the mnemonic accelerator. If there is no
--   mnemonic set up it returns <tt>GDK_KEY_VoidSymbol</tt>.
labelGetMnemonicKeyval :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Word32

-- | Retrieves the mnemonic target of this label.
--   
--   See <a>labelSetMnemonicWidget</a>.
labelGetMnemonicWidget :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe Widget)

-- | Returns natural line wrap mode used by the label.
--   
--   See <a>labelSetNaturalWrapMode</a>.
--   
--   <i>Since: 4.6</i>
labelGetNaturalWrapMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> m NaturalWrapMode

-- | Returns whether the label is selectable.
labelGetSelectable :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Gets the selected range of characters in the label.
--   
--   The returned <i><tt>start</tt></i> and <i><tt>end</tt></i> positions
--   are in characters.
labelGetSelectionBounds :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Bool, Int32, Int32)

-- | Returns whether the label is in single line mode.
labelGetSingleLineMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Gets the tab stops for the label.
--   
--   The returned array will be <tt>NULL</tt> if “standard” (8-space) tabs
--   are used.
--   
--   <i>Since: 4.8</i>
labelGetTabs :: (HasCallStack, MonadIO m, IsLabel a) => a -> m (Maybe TabArray)

-- | Gets the text of the label.
--   
--   The returned text is as it appears on screen. This does not include
--   any embedded underlines indicating mnemonics or Pango markup. (See
--   <a>labelGetLabel</a>)
labelGetText :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Text

-- | Returns whether the label’s text is interpreted as Pango markup.
--   
--   See <a>labelSetUseMarkup</a>.
labelGetUseMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Returns whether underlines in the label indicate mnemonics.
--   
--   See <a>labelSetUseUnderline</a>.
labelGetUseUnderline :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Retrieves the desired width of the label in characters.
--   
--   See <a>labelSetWidthChars</a>.
labelGetWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Int32

-- | Returns whether lines in the label are automatically wrapped.
--   
--   See <a>labelSetWrap</a>.
labelGetWrap :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Bool

-- | Returns line wrap mode used by the label.
--   
--   See <a>labelSetWrapMode</a>.
labelGetWrapMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> m WrapMode

-- | Gets the <tt>xalign</tt> of the label.
--   
--   See the <a>Label:xalign</a> property.
labelGetXalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Float

-- | Gets the <tt>yalign</tt> of the label.
--   
--   See the <a>Label:yalign</a> property.
labelGetYalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> m Float

-- | Creates a new label with the given text inside it.
--   
--   You can pass <tt>NULL</tt> to get an empty label widget.
labelNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Label

-- | Creates a new label with the given text inside it, and a mnemonic.
--   
--   If characters in <i><tt>str</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use '__' (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic. The mnemonic key
--   can be used to activate another widget, chosen automatically, or
--   explicitly using <a>labelSetMnemonicWidget</a>.
--   
--   If <a>labelSetMnemonicWidget</a> is not called, then the first
--   activatable ancestor of the label will be chosen as the mnemonic
--   widget. For instance, if the label is inside a button or menu item,
--   the button or menu item will automatically become the mnemonic widget
--   and be activated by the mnemonic.
labelNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m Label

-- | Selects a range of characters in the label, if the label is
--   selectable.
--   
--   See <a>labelSetSelectable</a>. If the label is not selectable, this
--   function has no effect. If <i><tt>startOffset</tt></i> or
--   <i><tt>endOffset</tt></i> are -1, then the end of the label will be
--   substituted.
labelSelectRegion :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> Int32 -> m ()

-- | Apply attributes to the label text.
--   
--   The attributes set with this function will be applied and merged with
--   any other attributes previously effected by way of the
--   <a>Label:useUnderline</a> or <a>Label:useMarkup</a> properties
--   
--   While it is not recommended to mix markup strings with manually set
--   attributes, if you must; know that the attributes will be applied to
--   the label after the markup string is parsed.
labelSetAttributes :: (HasCallStack, MonadIO m, IsLabel a) => a -> Maybe AttrList -> m ()

-- | Sets the mode used to ellipsize the text.
--   
--   The text will be ellipsized if there is not enough space to render the
--   entire string.
labelSetEllipsize :: (HasCallStack, MonadIO m, IsLabel a) => a -> EllipsizeMode -> m ()

-- | Sets a menu model to add to the context menu of the label.
labelSetExtraMenu :: (HasCallStack, MonadIO m, IsLabel a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets the alignment of lines in the label relative to each other.
--   
--   This function has no effect on labels containing only a single line.
--   
--   <a>JustificationLeft</a> is the default value when the widget is first
--   created with <a>labelNew</a>.
--   
--   If you instead want to set the alignment of the label as a whole, use
--   <a>widgetSetHalign</a> instead.
labelSetJustify :: (HasCallStack, MonadIO m, IsLabel a) => a -> Justification -> m ()

-- | Sets the text of the label.
--   
--   The label is interpreted as including embedded underlines and/or Pango
--   markup depending on the values of the <a>Label:useUnderline</a> and
--   <a>Label:useMarkup</a> properties.
labelSetLabel :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the number of lines to which an ellipsized, wrapping label should
--   be limited.
--   
--   This has no effect if the label is not wrapping or ellipsized. Set
--   this to -1 if you don’t want to limit the number of lines.
labelSetLines :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | Sets the labels text and attributes from markup.
--   
--   The string must be marked up with Pango markup (see
--   <a>parseMarkup</a>).
--   
--   If <i><tt>str</tt></i> is external data, you may need to escape it
--   with <a>markupEscapeText</a> or
--   <tt><i>GLib.markup_printf_escaped</i></tt>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *self = gtk_label_new (NULL);
--   const char *str = "...";
--   const char *format = "&lt;span style=\"italic\"&gt;\%s&lt;/span&gt;";
--   char *markup;
--   
--   markup = g_markup_printf_escaped (format, str);
--   gtk_label_set_markup (GTK_LABEL (self), markup);
--   g_free (markup);
--   </pre>
--   
--   This function sets the <a>Label:useMarkup</a> property to true.
--   
--   Also see <a>labelSetText</a>.
labelSetMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the labels text, attributes and mnemonic from markup.
--   
--   Parses <i><tt>str</tt></i> which is marked up with Pango markup (see
--   <a>parseMarkup</a>), setting the label’s text and attribute list based
--   on the parse results. If characters in <i><tt>str</tt></i> are
--   preceded by an underscore, they are underlined indicating that they
--   represent a keyboard accelerator called a mnemonic.
--   
--   The mnemonic key can be used to activate another widget, chosen
--   automatically, or explicitly using <a>labelSetMnemonicWidget</a>.
labelSetMarkupWithMnemonic :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the maximum width of the label in characters.
labelSetMaxWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | Associate the label with its mnemonic target.
--   
--   If the label has been set so that it has a mnemonic key (using i.e.
--   <a>labelSetMarkupWithMnemonic</a>, <a>labelSetTextWithMnemonic</a>,
--   <a>labelNewWithMnemonic</a> or the
--   [property<i><tt>gtk</tt></i>.Label:use_underline] property) the label
--   can be associated with a widget that is the target of the mnemonic.
--   When the label is inside a widget (like a <a>Button</a> or a
--   <a>Notebook</a> tab) it is automatically associated with the correct
--   widget, but sometimes (i.e. when the target is a <a>Entry</a> next to
--   the label) you need to set it explicitly using this function.
--   
--   The target widget will be accelerated by emitting the
--   <a>Widget::mnemonicActivate</a> signal on it. The default handler for
--   this signal will activate the widget if there are no mnemonic
--   collisions and toggle focus between the colliding widgets otherwise.
labelSetMnemonicWidget :: (HasCallStack, MonadIO m, IsLabel a, IsWidget b) => a -> Maybe b -> m ()

-- | Selects the line wrapping for the natural size request.
--   
--   This only affects the natural size requested, for the actual wrapping
--   used, see the <a>Label:wrapMode</a> property.
--   
--   <i>Since: 4.6</i>
labelSetNaturalWrapMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> NaturalWrapMode -> m ()

-- | Makes text in the label selectable.
--   
--   Selectable labels allow the user to select text from the label, for
--   copy-and-paste.
labelSetSelectable :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets whether the label is in single line mode.
labelSetSingleLineMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets tab stops for the label.
--   
--   <i>Since: 4.8</i>
labelSetTabs :: (HasCallStack, MonadIO m, IsLabel a) => a -> Maybe TabArray -> m ()

-- | Sets the text for the label.
--   
--   It overwrites any text that was there before and clears any previously
--   set mnemonic accelerators, and sets the <a>Label:useUnderline</a> and
--   <a>Label:useMarkup</a> properties to false.
--   
--   Also see <a>labelSetMarkup</a>.
labelSetText :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets the text for the label, with mnemonics.
--   
--   If characters in <i><tt>str</tt></i> are preceded by an underscore,
--   they are underlined indicating that they represent a keyboard
--   accelerator called a mnemonic. The mnemonic key can be used to
--   activate another widget, chosen automatically, or explicitly using
--   <a>labelSetMnemonicWidget</a>.
labelSetTextWithMnemonic :: (HasCallStack, MonadIO m, IsLabel a) => a -> Text -> m ()

-- | Sets whether the text of the label contains markup.
--   
--   See <a>labelSetMarkup</a>.
labelSetUseMarkup :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets whether underlines in the text indicate mnemonics.
labelSetUseUnderline :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Sets the desired width in characters of the label.
labelSetWidthChars :: (HasCallStack, MonadIO m, IsLabel a) => a -> Int32 -> m ()

-- | Toggles line wrapping within the label.
--   
--   True makes it break lines if text exceeds the widget’s size. false
--   lets the text get cut off by the edge of the widget if it exceeds the
--   widget size.
--   
--   Note that setting line wrapping to true does not make the label wrap
--   at its parent widget’s width, because GTK widgets conceptually can’t
--   make their requisition depend on the parent widget’s size. For a label
--   that wraps at a specific position, set the label’s width using
--   <a>widgetSetSizeRequest</a>.
labelSetWrap :: (HasCallStack, MonadIO m, IsLabel a) => a -> Bool -> m ()

-- | Controls how line wrapping is done.
--   
--   This only affects the label if line wrapping is on. (See
--   <a>labelSetWrap</a>)
--   
--   The default is <a>WrapModeWord</a>, which means wrap on word
--   boundaries.
--   
--   For sizing behavior, also consider the <a>Label:naturalWrapMode</a>
--   property.
labelSetWrapMode :: (HasCallStack, MonadIO m, IsLabel a) => a -> WrapMode -> m ()

-- | Sets the <tt>xalign</tt> of the label.
--   
--   See the <a>Label:xalign</a> property.
labelSetXalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> Float -> m ()

-- | Sets the <tt>yalign</tt> of the label.
--   
--   See the <a>Label:yalign</a> property.
labelSetYalign :: (HasCallStack, MonadIO m, IsLabel a) => a -> Float -> m ()

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearLabelAttributes :: (MonadIO m, IsLabel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelAttributes :: (IsLabel o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #attributes
--   </pre>
getLabelAttributes :: (MonadIO m, IsLabel o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #attributes <a>:=</a> value ]
--   </pre>
setLabelAttributes :: (MonadIO m, IsLabel o) => o -> AttrList -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelEllipsize :: (IsLabel o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #ellipsize
--   </pre>
getLabelEllipsize :: (MonadIO m, IsLabel o) => o -> m EllipsizeMode

-- | Set the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #ellipsize <a>:=</a> value ]
--   </pre>
setLabelEllipsize :: (MonadIO m, IsLabel o) => o -> EllipsizeMode -> m ()

-- | Set the value of the “<tt>extra-menu</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #extraMenu
--   </pre>
clearLabelExtraMenu :: (MonadIO m, IsLabel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>extra-menu</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelExtraMenu :: (IsLabel o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #extraMenu
--   </pre>
getLabelExtraMenu :: (MonadIO m, IsLabel o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #extraMenu <a>:=</a> value ]
--   </pre>
setLabelExtraMenu :: (MonadIO m, IsLabel o, IsMenuModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>justify</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelJustify :: (IsLabel o, MonadIO m) => Justification -> m (GValueConstruct o)

-- | Get the value of the “<tt>justify</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #justify
--   </pre>
getLabelJustify :: (MonadIO m, IsLabel o) => o -> m Justification

-- | Set the value of the “<tt>justify</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #justify <a>:=</a> value ]
--   </pre>
setLabelJustify :: (MonadIO m, IsLabel o) => o -> Justification -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelLabel :: (IsLabel o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #label
--   </pre>
getLabelLabel :: (MonadIO m, IsLabel o) => o -> m Text

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #label <a>:=</a> value ]
--   </pre>
setLabelLabel :: (MonadIO m, IsLabel o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>lines</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelLines :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #lines
--   </pre>
getLabelLines :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “<tt>lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #lines <a>:=</a> value ]
--   </pre>
setLabelLines :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width-chars</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLabelMaxWidthChars :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #maxWidthChars
--   </pre>
getLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #maxWidthChars <a>:=</a> value ]
--   </pre>
setLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Get the value of the “<tt>mnemonic-keyval</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #mnemonicKeyval
--   </pre>
getLabelMnemonicKeyval :: (MonadIO m, IsLabel o) => o -> m Word32

-- | Set the value of the “<tt>mnemonic-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #mnemonicWidget
--   </pre>
clearLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mnemonic-widget</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLabelMnemonicWidget :: (IsLabel o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>mnemonic-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #mnemonicWidget
--   </pre>
getLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>mnemonic-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #mnemonicWidget <a>:=</a> value ]
--   </pre>
setLabelMnemonicWidget :: (MonadIO m, IsLabel o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>natural-wrap-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLabelNaturalWrapMode :: (IsLabel o, MonadIO m) => NaturalWrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>natural-wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #naturalWrapMode
--   </pre>
getLabelNaturalWrapMode :: (MonadIO m, IsLabel o) => o -> m NaturalWrapMode

-- | Set the value of the “<tt>natural-wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #naturalWrapMode <a>:=</a> value ]
--   </pre>
setLabelNaturalWrapMode :: (MonadIO m, IsLabel o) => o -> NaturalWrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selectable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelSelectable :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #selectable
--   </pre>
getLabelSelectable :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>selectable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #selectable <a>:=</a> value ]
--   </pre>
setLabelSelectable :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>single-line-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructLabelSingleLineMode :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>single-line-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #singleLineMode
--   </pre>
getLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>single-line-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #singleLineMode <a>:=</a> value ]
--   </pre>
setLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Set the value of the “<tt>tabs</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tabs
--   </pre>
clearLabelTabs :: (MonadIO m, IsLabel o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelTabs :: (IsLabel o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #tabs
--   </pre>
getLabelTabs :: (MonadIO m, IsLabel o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #tabs <a>:=</a> value ]
--   </pre>
setLabelTabs :: (MonadIO m, IsLabel o) => o -> TabArray -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-markup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelUseMarkup :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #useMarkup
--   </pre>
getLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #useMarkup <a>:=</a> value ]
--   </pre>
setLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLabelUseUnderline :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #useUnderline
--   </pre>
getLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #useUnderline <a>:=</a> value ]
--   </pre>
setLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-chars</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructLabelWidthChars :: (IsLabel o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #widthChars
--   </pre>
getLabelWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32

-- | Set the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #widthChars <a>:=</a> value ]
--   </pre>
setLabelWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelWrap :: (IsLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #wrap
--   </pre>
getLabelWrap :: (MonadIO m, IsLabel o) => o -> m Bool

-- | Set the value of the “<tt>wrap</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #wrap <a>:=</a> value ]
--   </pre>
setLabelWrap :: (MonadIO m, IsLabel o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructLabelWrapMode :: (IsLabel o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #wrapMode
--   </pre>
getLabelWrapMode :: (MonadIO m, IsLabel o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #wrapMode <a>:=</a> value ]
--   </pre>
setLabelWrapMode :: (MonadIO m, IsLabel o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelXalign :: (IsLabel o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #xalign
--   </pre>
getLabelXalign :: (MonadIO m, IsLabel o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #xalign <a>:=</a> value ]
--   </pre>
setLabelXalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructLabelYalign :: (IsLabel o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> label #yalign
--   </pre>
getLabelYalign :: (MonadIO m, IsLabel o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> label [ #yalign <a>:=</a> value ]
--   </pre>
setLabelYalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()

-- | Gets emitted when the user activates a link in the label.
--   
--   The <tt>::activate-current-link</tt> is a <a>keybinding signal</a>.
--   
--   Applications may also emit the signal with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   activation of URIs programmatically.
--   
--   The default bindings for this signal are all forms of the
--   &lt;kbd&gt;Enter&lt;/kbd&gt; key.
type LabelActivateCurrentLinkCallback = IO ()

-- | Connect a signal handler for the <a>activateCurrentLink</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> label #activateCurrentLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelActivateCurrentLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateCurrentLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCurrentLink</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> label #activateCurrentLink callback
--   </pre>
onLabelActivateCurrentLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateCurrentLinkCallback) -> m SignalHandlerId

-- | Gets emitted to activate a URI.
--   
--   Applications may connect to it to override the default behaviour,
--   which is to call <a>fileLauncherLaunch</a>.
type LabelActivateLinkCallback = Text -> IO Bool

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> label #activateLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelActivateLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> label #activateLink callback
--   </pre>
onLabelActivateLink :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelActivateLinkCallback) -> m SignalHandlerId

-- | Gets emitted to copy the selection to the clipboard.
--   
--   The <tt>::copy-clipboard</tt> signal is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;c&lt;/kbd&gt;.
type LabelCopyClipboardCallback = IO ()

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> label #copyClipboard callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelCopyClipboard :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelCopyClipboardCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>copyClipboard</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> label #copyClipboard callback
--   </pre>
onLabelCopyClipboard :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelCopyClipboardCallback) -> m SignalHandlerId

-- | Gets emitted when the user initiates a cursor movement.
--   
--   The <tt>::move-cursor</tt> signal is a <a>keybinding signal</a>. If
--   the cursor is not visible in <i><tt>entry</tt></i>, this signal causes
--   the viewport to be moved instead.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>GObject.signal_emit_by_name</i></tt> if they need to control
--   the cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the &lt;kbd&gt;Shift&lt;/kbd&gt; modifier extends the selection,
--   the variant without the &lt;kbd&gt;Shift&lt;/kbd&gt; modifier does
--   not. There are too many key combinations to list them all here.
--   
--   <ul>
--   <li>&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;↑&lt;/kbd&gt;, &lt;kbd&gt;↓&lt;/kbd&gt; move by individual
--   characters/lines</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;←&lt;/kbd&gt;, etc. move by
--   words/paragraphs</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt; and &lt;kbd&gt;End&lt;/kbd&gt; move to
--   the ends of the buffer</li>
--   </ul>
type LabelMoveCursorCallback = MovementStep -> Int32 -> Bool -> IO ()

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> label #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterLabelMoveCursor :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> label #moveCursor callback
--   </pre>
onLabelMoveCursor :: (IsLabel a, MonadIO m) => a -> ((?self :: a) => LabelMoveCursorCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Label.Label
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Label.Label
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Label.Label
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Label.Label)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Label.Label o) => GI.Gtk.Objects.Label.IsLabel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Label.Label
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Label.Label


-- | Shows text in a predefined area.
--   
--   You likely want to use <tt>GtkLabel</tt> instead as this widget is
--   intended only for a small subset of use cases. The main scenario
--   envisaged is inside lists such as <tt>GtkColumnView</tt>.
--   
--   While a <tt>GtkLabel</tt> sizes itself depending on the text that is
--   displayed, <tt>GtkInscription</tt> is given a size and inscribes the
--   given text into that space as well as it can.
--   
--   Users of this widget should take care to plan behaviour for the common
--   case where the text doesn't fit exactly in the allocated space.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkInscription</tt> has a single CSS node with the name label.
--   
--   <i>Since: 4.8</i>
module GI.Gtk.Objects.Inscription

-- | Memory-managed wrapper type.
newtype Inscription
Inscription :: ManagedPtr Inscription -> Inscription

-- | Type class for types which can be safely cast to <a>Inscription</a>,
--   for instance with <a>toInscription</a>.
class (GObject o, IsDescendantOf Inscription o) => IsInscription o

-- | Cast to <a>Inscription</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toInscription :: (MonadIO m, IsInscription o) => o -> m Inscription

-- | Gets the inscription's attribute list.
--   
--   <i>Since: 4.8</i>
inscriptionGetAttributes :: (HasCallStack, MonadIO m, IsInscription a) => a -> m (Maybe AttrList)

-- | Gets the <tt>min-chars</tt> of the inscription.
--   
--   See the <a>Inscription:minChars</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionGetMinChars :: (HasCallStack, MonadIO m, IsInscription a) => a -> m Word32

-- | Gets the <tt>min-lines</tt> of the inscription.
--   
--   See the <a>Inscription:minLines</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionGetMinLines :: (HasCallStack, MonadIO m, IsInscription a) => a -> m Word32

-- | Gets the <tt>nat-chars</tt> of the inscription.
--   
--   See the <a>Inscription:natChars</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionGetNatChars :: (HasCallStack, MonadIO m, IsInscription a) => a -> m Word32

-- | Gets the <tt>nat-lines</tt> of the inscription.
--   
--   See the <a>Inscription:natLines</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionGetNatLines :: (HasCallStack, MonadIO m, IsInscription a) => a -> m Word32

-- | Gets the text that is displayed.
--   
--   <i>Since: 4.8</i>
inscriptionGetText :: (HasCallStack, MonadIO m, IsInscription a) => a -> m (Maybe Text)

-- | Gets the inscription's overflow method.
--   
--   <i>Since: 4.8</i>
inscriptionGetTextOverflow :: (HasCallStack, MonadIO m, IsInscription a) => a -> m InscriptionOverflow

-- | Returns line wrap mode used by the inscription.
--   
--   See <a>inscriptionSetWrapMode</a>.
--   
--   <i>Since: 4.8</i>
inscriptionGetWrapMode :: (HasCallStack, MonadIO m, IsInscription a) => a -> m WrapMode

-- | Gets the <tt>xalign</tt> of the inscription.
--   
--   See the <a>Inscription:xalign</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionGetXalign :: (HasCallStack, MonadIO m, IsInscription a) => a -> m Float

-- | Gets the <tt>yalign</tt> of the inscription.
--   
--   See the <a>Inscription:yalign</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionGetYalign :: (HasCallStack, MonadIO m, IsInscription a) => a -> m Float

-- | Creates a new <tt>GtkInscription</tt> with the given text.
--   
--   <i>Since: 4.8</i>
inscriptionNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Inscription

-- | Apply attributes to the inscription text.
--   
--   These attributes will not be evaluated for sizing the inscription.
--   
--   <i>Since: 4.8</i>
inscriptionSetAttributes :: (HasCallStack, MonadIO m, IsInscription a) => a -> Maybe AttrList -> m ()

-- | Utility function to set the text and attributes to be displayed.
--   
--   See the <a>Inscription:markup</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionSetMarkup :: (HasCallStack, MonadIO m, IsInscription a) => a -> Maybe Text -> m ()

-- | Sets the <tt>min-chars</tt> of the inscription.
--   
--   See the <a>Inscription:minChars</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionSetMinChars :: (HasCallStack, MonadIO m, IsInscription a) => a -> Word32 -> m ()

-- | Sets the <tt>min-lines</tt> of the inscription.
--   
--   See the <a>Inscription:minLines</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionSetMinLines :: (HasCallStack, MonadIO m, IsInscription a) => a -> Word32 -> m ()

-- | Sets the <tt>nat-chars</tt> of the inscription.
--   
--   See the <a>Inscription:natChars</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionSetNatChars :: (HasCallStack, MonadIO m, IsInscription a) => a -> Word32 -> m ()

-- | Sets the <tt>nat-lines</tt> of the inscription.
--   
--   See the <a>Inscription:natLines</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionSetNatLines :: (HasCallStack, MonadIO m, IsInscription a) => a -> Word32 -> m ()

-- | Sets the text to be displayed.
--   
--   <i>Since: 4.8</i>
inscriptionSetText :: (HasCallStack, MonadIO m, IsInscription a) => a -> Maybe Text -> m ()

-- | Sets what to do when the text doesn't fit.
--   
--   <i>Since: 4.8</i>
inscriptionSetTextOverflow :: (HasCallStack, MonadIO m, IsInscription a) => a -> InscriptionOverflow -> m ()

-- | Controls how line wrapping is done.
--   
--   <i>Since: 4.8</i>
inscriptionSetWrapMode :: (HasCallStack, MonadIO m, IsInscription a) => a -> WrapMode -> m ()

-- | Sets the <tt>xalign</tt> of the inscription.
--   
--   See the <a>Inscription:xalign</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionSetXalign :: (HasCallStack, MonadIO m, IsInscription a) => a -> Float -> m ()

-- | Sets the <tt>yalign</tt> of the inscription.
--   
--   See the <a>Inscription:yalign</a> property.
--   
--   <i>Since: 4.8</i>
inscriptionSetYalign :: (HasCallStack, MonadIO m, IsInscription a) => a -> Float -> m ()

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearInscriptionAttributes :: (MonadIO m, IsInscription o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInscriptionAttributes :: (IsInscription o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #attributes
--   </pre>
getInscriptionAttributes :: (MonadIO m, IsInscription o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #attributes <a>:=</a> value ]
--   </pre>
setInscriptionAttributes :: (MonadIO m, IsInscription o) => o -> AttrList -> m ()

-- | Set the value of the “<tt>markup</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #markup
--   </pre>
clearInscriptionMarkup :: (MonadIO m, IsInscription o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>markup</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructInscriptionMarkup :: (IsInscription o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #markup <a>:=</a> value ]
--   </pre>
setInscriptionMarkup :: (MonadIO m, IsInscription o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-chars</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInscriptionMinChars :: (IsInscription o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #minChars
--   </pre>
getInscriptionMinChars :: (MonadIO m, IsInscription o) => o -> m Word32

-- | Set the value of the “<tt>min-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #minChars <a>:=</a> value ]
--   </pre>
setInscriptionMinChars :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-lines</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInscriptionMinLines :: (IsInscription o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #minLines
--   </pre>
getInscriptionMinLines :: (MonadIO m, IsInscription o) => o -> m Word32

-- | Set the value of the “<tt>min-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #minLines <a>:=</a> value ]
--   </pre>
setInscriptionMinLines :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>nat-chars</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInscriptionNatChars :: (IsInscription o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>nat-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #natChars
--   </pre>
getInscriptionNatChars :: (MonadIO m, IsInscription o) => o -> m Word32

-- | Set the value of the “<tt>nat-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #natChars <a>:=</a> value ]
--   </pre>
setInscriptionNatChars :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>nat-lines</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInscriptionNatLines :: (IsInscription o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>nat-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #natLines
--   </pre>
getInscriptionNatLines :: (MonadIO m, IsInscription o) => o -> m Word32

-- | Set the value of the “<tt>nat-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #natLines <a>:=</a> value ]
--   </pre>
setInscriptionNatLines :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearInscriptionText :: (MonadIO m, IsInscription o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructInscriptionText :: (IsInscription o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #text
--   </pre>
getInscriptionText :: (MonadIO m, IsInscription o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #text <a>:=</a> value ]
--   </pre>
setInscriptionText :: (MonadIO m, IsInscription o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-overflow</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructInscriptionTextOverflow :: (IsInscription o, MonadIO m) => InscriptionOverflow -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-overflow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #textOverflow
--   </pre>
getInscriptionTextOverflow :: (MonadIO m, IsInscription o) => o -> m InscriptionOverflow

-- | Set the value of the “<tt>text-overflow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #textOverflow <a>:=</a> value ]
--   </pre>
setInscriptionTextOverflow :: (MonadIO m, IsInscription o) => o -> InscriptionOverflow -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInscriptionWrapMode :: (IsInscription o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #wrapMode
--   </pre>
getInscriptionWrapMode :: (MonadIO m, IsInscription o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #wrapMode <a>:=</a> value ]
--   </pre>
setInscriptionWrapMode :: (MonadIO m, IsInscription o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructInscriptionXalign :: (IsInscription o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #xalign
--   </pre>
getInscriptionXalign :: (MonadIO m, IsInscription o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #xalign <a>:=</a> value ]
--   </pre>
setInscriptionXalign :: (MonadIO m, IsInscription o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructInscriptionYalign :: (IsInscription o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> inscription #yalign
--   </pre>
getInscriptionYalign :: (MonadIO m, IsInscription o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> inscription [ #yalign <a>:=</a> value ]
--   </pre>
setInscriptionYalign :: (MonadIO m, IsInscription o) => o -> Float -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Inscription.Inscription
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Inscription.Inscription
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Inscription.Inscription
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Inscription.Inscription)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Inscription.Inscription o) => GI.Gtk.Objects.Inscription.IsInscription o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Inscription.Inscription
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Inscription.Inscription


-- | <tt>GtkInfoBar</tt> can be used to show messages to the user without a
--   dialog.
--   
--   &lt;picture&gt; &lt;source srcset="info-bar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkInfoBar" src="info-bar.png"&gt; &lt;/picture&gt;
--   
--   It is often temporarily shown at the top or bottom of a document. In
--   contrast to <a>Dialog</a>, which has an action area at the bottom,
--   <tt>GtkInfoBar</tt> has an action area at the side.
--   
--   The API of <tt>GtkInfoBar</tt> is very similar to <tt>GtkDialog</tt>,
--   allowing you to add buttons to the action area with
--   <a>infoBarAddButton</a> or
--   <a>InfoBar</a>.<tt><i>new_with_buttons</i></tt>(). The sensitivity of
--   action widgets can be controlled with
--   <a>infoBarSetResponseSensitive</a>.
--   
--   To add widgets to the main content area of a <tt>GtkInfoBar</tt>, use
--   <a>infoBarAddChild</a>.
--   
--   Similar to <a>MessageDialog</a>, the contents of a <tt>GtkInfoBar</tt>
--   can by classified as error message, warning, informational message,
--   etc, by using <a>infoBarSetMessageType</a>. GTK may use the message
--   type to determine how the message is displayed.
--   
--   A simple example for using a <tt>GtkInfoBar</tt>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *message_label;
--   GtkWidget *widget;
--   GtkWidget *grid;
--   GtkInfoBar *bar;
--   
--   // set up info bar
--   widget = gtk_info_bar_new ();
--   bar = GTK_INFO_BAR (widget);
--   grid = gtk_grid_new ();
--   
--   message_label = gtk_label_new ("");
--   gtk_info_bar_add_child (bar, message_label);
--   gtk_info_bar_add_button (bar,
--                            _("_OK"),
--                            GTK_RESPONSE_OK);
--   g_signal_connect (bar,
--                     "response",
--                     G_CALLBACK (gtk_widget_hide),
--                     NULL);
--   gtk_grid_attach (GTK_GRID (grid),
--                    widget,
--                    0, 2, 1, 1);
--   
--   // ...
--   
--   // show an error message
--   gtk_label_set_text (GTK_LABEL (message_label), "An error occurred!");
--   gtk_info_bar_set_message_type (bar, GTK_MESSAGE_ERROR);
--   gtk_widget_show (bar);
--   </pre>
--   
--   <h1>GtkInfoBar as GtkBuildable</h1>
--   
--   <tt>GtkInfoBar</tt> supports a custom <tt>&lt;action-widgets&gt;</tt>
--   element, which can contain multiple <tt>&lt;action-widget&gt;</tt>
--   elements. The “response” attribute specifies a numeric response, and
--   the content of the element is the id of widget (which should be a
--   child of the dialogs <i><tt>actionArea</tt></i>).
--   
--   <tt>GtkInfoBar</tt> supports adding action widgets by specifying
--   “action” as the “type” attribute of a <tt>&lt;child&gt;</tt> element.
--   The widget will be added either to the action area. The response id
--   has to be associated with the action widget using the
--   <tt>&lt;action-widgets&gt;</tt> element.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkInfoBar</tt> has a single CSS node with name infobar. The node
--   may get one of the style classes .info, .warning, .error or .question,
--   depending on the message type. If the info bar shows a close button,
--   that button will have the .close style class applied.
module GI.Gtk.Objects.InfoBar

-- | Memory-managed wrapper type.
newtype InfoBar
InfoBar :: ManagedPtr InfoBar -> InfoBar

-- | Type class for types which can be safely cast to <a>InfoBar</a>, for
--   instance with <a>toInfoBar</a>.
class (GObject o, IsDescendantOf InfoBar o) => IsInfoBar o

-- | Cast to <a>InfoBar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toInfoBar :: (MonadIO m, IsInfoBar o) => o -> m InfoBar

-- | Add an activatable widget to the action area of a <tt>GtkInfoBar</tt>.
--   
--   This also connects a signal handler that will emit the
--   <a>InfoBar::response</a> signal on the message area when the widget is
--   activated. The widget is appended to the end of the message areas
--   action area.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarAddActionWidget :: (HasCallStack, MonadIO m, IsInfoBar a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Adds a button with the given text.
--   
--   Clicking the button will emit the <a>InfoBar::response</a> signal with
--   the given response_id. The button is appended to the end of the info
--   bar's action area. The button widget is returned, but usually you
--   don't need it.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarAddButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Text -> Int32 -> m Button

-- | Adds a widget to the content area of the info bar.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarAddChild :: (HasCallStack, MonadIO m, IsInfoBar a, IsWidget b) => a -> b -> m ()

-- | Returns the message type of the message area.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarGetMessageType :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m MessageType

-- | Returns whether the info bar is currently revealed.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarGetRevealed :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Bool

-- | Returns whether the widget will display a standard close button.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarGetShowCloseButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> m Bool

-- | Creates a new <tt>GtkInfoBar</tt> object.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarNew :: (HasCallStack, MonadIO m) => m InfoBar

-- | Removes a widget from the action area of <i><tt>infoBar</tt></i>.
--   
--   The widget must have been put there by a call to
--   <a>infoBarAddActionWidget</a> or <a>infoBarAddButton</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarRemoveActionWidget :: (HasCallStack, MonadIO m, IsInfoBar a, IsWidget b) => a -> b -> m ()

-- | Removes a widget from the content area of the info bar.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarRemoveChild :: (HasCallStack, MonadIO m, IsInfoBar a, IsWidget b) => a -> b -> m ()

-- | Emits the “response” signal with the given <i><tt>responseId</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarResponse :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Int32 -> m ()

-- | Sets the last widget in the info bar’s action area with the given
--   response_id as the default widget for the dialog.
--   
--   Pressing “Enter” normally activates the default widget.
--   
--   Note that this function currently requires <i><tt>infoBar</tt></i> to
--   be added to a widget hierarchy.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarSetDefaultResponse :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Int32 -> m ()

-- | Sets the message type of the message area.
--   
--   GTK uses this type to determine how the message is displayed.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarSetMessageType :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> MessageType -> m ()

-- | Sets the sensitivity of action widgets for <i><tt>responseId</tt></i>.
--   
--   Calls <tt>gtk_widget_set_sensitive (widget, setting)</tt> for each
--   widget in the info bars’s action area with the given
--   <i><tt>responseId</tt></i>. A convenient way to sensitize/desensitize
--   buttons.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarSetResponseSensitive :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Int32 -> Bool -> m ()

-- | Sets whether the <tt>GtkInfoBar</tt> is revealed.
--   
--   Changing this will make <i><tt>infoBar</tt></i> reveal or conceal
--   itself via a sliding transition.
--   
--   Note: this does not show or hide <i><tt>infoBar</tt></i> in the
--   <a>Widget:visible</a> sense, so revealing has no effect if
--   <a>Widget:visible</a> is <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarSetRevealed :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Bool -> m ()

-- | If true, a standard close button is shown.
--   
--   When clicked it emits the response <a>ResponseTypeClose</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
infoBarSetShowCloseButton :: (HasCallStack, MonadIO m, IsInfoBar a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>message-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructInfoBarMessageType :: (IsInfoBar o, MonadIO m) => MessageType -> m (GValueConstruct o)

-- | Get the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> infoBar #messageType
--   </pre>
getInfoBarMessageType :: (MonadIO m, IsInfoBar o) => o -> m MessageType

-- | Set the value of the “<tt>message-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> infoBar [ #messageType <a>:=</a> value ]
--   </pre>
setInfoBarMessageType :: (MonadIO m, IsInfoBar o) => o -> MessageType -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>revealed</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructInfoBarRevealed :: (IsInfoBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> infoBar #revealed
--   </pre>
getInfoBarRevealed :: (MonadIO m, IsInfoBar o) => o -> m Bool

-- | Set the value of the “<tt>revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> infoBar [ #revealed <a>:=</a> value ]
--   </pre>
setInfoBarRevealed :: (MonadIO m, IsInfoBar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-close-button</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructInfoBarShowCloseButton :: (IsInfoBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> infoBar #showCloseButton
--   </pre>
getInfoBarShowCloseButton :: (MonadIO m, IsInfoBar o) => o -> m Bool

-- | Set the value of the “<tt>show-close-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> infoBar [ #showCloseButton <a>:=</a> value ]
--   </pre>
setInfoBarShowCloseButton :: (MonadIO m, IsInfoBar o) => o -> Bool -> m ()

-- | Gets emitted when the user uses a keybinding to dismiss the info bar.
--   
--   The <a>close</a> signal is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is the Escape key.
type InfoBarCloseCallback = IO ()

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> infoBar #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterInfoBarClose :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> infoBar #close callback
--   </pre>
onInfoBarClose :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarCloseCallback) -> m SignalHandlerId

-- | Emitted when an action widget is clicked.
--   
--   The signal is also emitted when the application programmer calls
--   <a>infoBarResponse</a>. The <i><tt>responseId</tt></i> depends on
--   which action widget was clicked.
type InfoBarResponseCallback = Int32 -> IO ()

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> infoBar #response callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterInfoBarResponse :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> infoBar #response callback
--   </pre>
onInfoBarResponse :: (IsInfoBar a, MonadIO m) => a -> ((?self :: a) => InfoBarResponseCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.InfoBar.InfoBar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.InfoBar.InfoBar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.InfoBar.InfoBar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.InfoBar.InfoBar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.InfoBar.InfoBar o) => GI.Gtk.Objects.InfoBar.IsInfoBar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.InfoBar.InfoBar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.InfoBar.InfoBar


-- | Displays an image.
--   
--   &lt;picture&gt; &lt;source srcset="image-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkImage" src="image.png"&gt; &lt;/picture&gt;
--   
--   Various kinds of object can be displayed as an image; most typically,
--   you would load a <tt>GdkTexture</tt> from a file, using the
--   convenience function <a>imageNewFromFile</a>, for instance:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *image = gtk_image_new_from_file ("myfile.png");
--   </pre>
--   
--   If the file isn’t loaded successfully, the image will contain a
--   “broken image” icon similar to that used in many web browsers.
--   
--   If you want to handle errors in loading the file yourself, for example
--   by displaying an error message, then load the image with an image
--   loading framework such as libglycin, then create the <tt>GtkImage</tt>
--   with <a>imageNewFromPaintable</a>.
--   
--   Sometimes an application will want to avoid depending on external data
--   files, such as image files. See the documentation of
--   <tt>GResource</tt> inside GIO, for details. In this case,
--   <a>Image:resource</a>, <a>imageNewFromResource</a>, and
--   <a>imageSetFromResource</a> should be used.
--   
--   <tt>GtkImage</tt> displays its image as an icon, with a size that is
--   determined by the application. See <a>Picture</a> if you want to show
--   an image at is actual size.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkImage</tt> has a single CSS node with the name <tt>image</tt>.
--   The style classes <tt>.normal-icons</tt> or <tt>.large-icons</tt> may
--   appear, depending on the <a>Image:iconSize</a> property.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkImage</tt> uses the <a>AccessibleRoleImg</a> role.
module GI.Gtk.Objects.Image

-- | Memory-managed wrapper type.
newtype Image
Image :: ManagedPtr Image -> Image

-- | Type class for types which can be safely cast to <a>Image</a>, for
--   instance with <a>toImage</a>.
class (GObject o, IsDescendantOf Image o) => IsImage o

-- | Cast to <a>Image</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toImage :: (MonadIO m, IsImage o) => o -> m Image

-- | Resets the image to be empty.
imageClear :: (HasCallStack, MonadIO m, IsImage a) => a -> m ()

-- | Gets the <tt>GIcon</tt> being displayed by the <tt>GtkImage</tt>.
--   
--   The storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeGicon</a> (see <a>imageGetStorageType</a>). The caller of
--   this function does not own a reference to the returned <tt>GIcon</tt>.
imageGetGicon :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Maybe Icon)

-- | Gets the icon name and size being displayed by the <tt>GtkImage</tt>.
--   
--   The storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypeIconName</a> (see <a>imageGetStorageType</a>). The
--   returned string is owned by the <tt>GtkImage</tt> and should not be
--   freed.
imageGetIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Maybe Text)

-- | Gets the icon size used by the <i><tt>image</tt></i> when rendering
--   icons.
imageGetIconSize :: (HasCallStack, MonadIO m, IsImage a) => a -> m IconSize

-- | Gets the image <tt>GdkPaintable</tt> being displayed by the
--   <tt>GtkImage</tt>.
--   
--   The storage type of the image must be <a>ImageTypeEmpty</a> or
--   <a>ImageTypePaintable</a> (see <a>imageGetStorageType</a>). The caller
--   of this function does not own a reference to the returned paintable.
imageGetPaintable :: (HasCallStack, MonadIO m, IsImage a) => a -> m (Maybe Paintable)

-- | Gets the pixel size used for named icons.
imageGetPixelSize :: (HasCallStack, MonadIO m, IsImage a) => a -> m Int32

-- | Gets the type of representation being used by the <tt>GtkImage</tt> to
--   store image data.
--   
--   If the <tt>GtkImage</tt> has no image data, the return value will be
--   <a>ImageTypeEmpty</a>.
imageGetStorageType :: (HasCallStack, MonadIO m, IsImage a) => a -> m ImageType

-- | Creates a new empty <tt>GtkImage</tt> widget.
imageNew :: (HasCallStack, MonadIO m) => m Image

-- | Creates a new <tt>GtkImage</tt> displaying the file
--   <i><tt>filename</tt></i>.
--   
--   If the file isn’t found or can’t be loaded, the resulting
--   <tt>GtkImage</tt> will display a “broken image” icon. This function
--   never returns <a>Nothing</a>, it always returns a valid
--   <tt>GtkImage</tt> widget.
--   
--   If you need to detect failures to load the file, use an image loading
--   framework such as libglycin to load the file yourself, then create the
--   <tt>GtkImage</tt> from the texture.
--   
--   The storage type (see <a>imageGetStorageType</a>) of the returned
--   image is not defined, it will be whatever is appropriate for
--   displaying the file.
imageNewFromFile :: (HasCallStack, MonadIO m) => [Char] -> m Image

-- | Creates a <tt>GtkImage</tt> displaying an icon from the current icon
--   theme.
--   
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead. If the current icon theme is changed, the icon will be
--   updated appropriately.
imageNewFromGicon :: (HasCallStack, MonadIO m, IsIcon a) => a -> m Image

-- | Creates a <tt>GtkImage</tt> displaying an icon from the current icon
--   theme.
--   
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead. If the current icon theme is changed, the icon will be
--   updated appropriately.
imageNewFromIconName :: (HasCallStack, MonadIO m) => Maybe Text -> m Image

-- | Creates a new <tt>GtkImage</tt> displaying <i><tt>paintable</tt></i>.
--   
--   The <tt>GtkImage</tt> does not assume a reference to the paintable;
--   you still need to unref it if you own references. <tt>GtkImage</tt>
--   will add its own reference rather than adopting yours.
--   
--   The <tt>GtkImage</tt> will track changes to the
--   <i><tt>paintable</tt></i> and update its size and contents in response
--   to it.
--   
--   Note that paintables are still subject to the icon size that is set on
--   the image. If you want to display a paintable at its intrinsic size,
--   use <a>Picture</a> instead.
--   
--   If <i><tt>paintable</tt></i> is a <a>SymbolicPaintable</a>, then it
--   will be recolored with the symbolic palette from the theme.
imageNewFromPaintable :: (HasCallStack, MonadIO m, IsPaintable a) => Maybe a -> m Image

-- | Creates a new <tt>GtkImage</tt> displaying <i><tt>pixbuf</tt></i>.
--   
--   The <tt>GtkImage</tt> does not assume a reference to the pixbuf; you
--   still need to unref it if you own references. <tt>GtkImage</tt> will
--   add its own reference rather than adopting yours.
--   
--   This is a helper for <a>imageNewFromPaintable</a>, and you can't get
--   back the exact pixbuf once this is called, only a texture.
--   
--   Note that this function just creates an <tt>GtkImage</tt> from the
--   pixbuf. The <tt>GtkImage</tt> created will not react to state changes.
--   Should you want that, you should use <a>imageNewFromIconName</a>.

-- | <i>Deprecated: (Since version 4.12)Use <a>imageNewFromPaintable</a>
--   and<a>textureNewForPixbuf</a> instead</i>
imageNewFromPixbuf :: (HasCallStack, MonadIO m, IsPixbuf a) => Maybe a -> m Image

-- | Creates a new <tt>GtkImage</tt> displaying the resource file
--   <i><tt>resourcePath</tt></i>.
--   
--   If the file isn’t found or can’t be loaded, the resulting
--   <tt>GtkImage</tt> will display a “broken image” icon. This function
--   never returns <a>Nothing</a>, it always returns a valid
--   <tt>GtkImage</tt> widget.
--   
--   If you need to detect failures to load the file, use an image loading
--   framework such as libglycin to load the file yourself, then create the
--   <tt>GtkImage</tt> from the texture.
--   
--   The storage type (see <a>imageGetStorageType</a>) of the returned
--   image is not defined, it will be whatever is appropriate for
--   displaying the file.
imageNewFromResource :: (HasCallStack, MonadIO m) => Text -> m Image

-- | Sets a <tt>GtkImage</tt> to show a file.
--   
--   See <a>imageNewFromFile</a> for details.
--   
--   ::: warning Note that this function should not be used with untrusted
--   data. Use a proper image loading framework such as libglycin, which
--   can load many image formats into a <tt>GdkTexture</tt>, and then use
--   <a>imageSetFromPaintable</a>.
imageSetFromFile :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe [Char] -> m ()

-- | Sets a <tt>GtkImage</tt> to show a <tt>GIcon</tt>.
--   
--   See <a>imageNewFromGicon</a> for details.
imageSetFromGicon :: (HasCallStack, MonadIO m, IsImage a, IsIcon b) => a -> b -> m ()

-- | Sets a <tt>GtkImage</tt> to show a named icon.
--   
--   See <a>imageNewFromIconName</a> for details.
imageSetFromIconName :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> m ()

-- | Sets a <tt>GtkImage</tt> to show a <tt>GdkPaintable</tt>.
--   
--   See <a>imageNewFromPaintable</a> for details.
imageSetFromPaintable :: (HasCallStack, MonadIO m, IsImage a, IsPaintable b) => a -> Maybe b -> m ()

-- | Sets a <tt>GtkImage</tt> to show a <tt>GdkPixbuf</tt>.
--   
--   See <a>imageNewFromPixbuf</a> for details.
--   
--   Note: This is a helper for <a>imageSetFromPaintable</a>, and you can't
--   get back the exact pixbuf once this is called, only a paintable.

-- | <i>Deprecated: (Since version 4.12)Use <a>imageSetFromPaintable</a>
--   instead</i>
imageSetFromPixbuf :: (HasCallStack, MonadIO m, IsImage a, IsPixbuf b) => a -> Maybe b -> m ()

-- | Sets a <tt>GtkImage</tt> to show a resource.
--   
--   See <a>imageNewFromResource</a> for details.
imageSetFromResource :: (HasCallStack, MonadIO m, IsImage a) => a -> Maybe Text -> m ()

-- | Suggests an icon size to the theme for named icons.
imageSetIconSize :: (HasCallStack, MonadIO m, IsImage a) => a -> IconSize -> m ()

-- | Sets the pixel size to use for named icons.
--   
--   If the pixel size is set to a value != -1, it is used instead of the
--   icon size set by <a>imageSetIconSize</a>.
imageSetPixelSize :: (HasCallStack, MonadIO m, IsImage a) => a -> Int32 -> m ()

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearImageFile :: (MonadIO m, IsImage o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImageFile :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #file
--   </pre>
getImageFile :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #file <a>:=</a> value ]
--   </pre>
setImageFile :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gicon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructImageGicon :: (IsImage o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #gicon
--   </pre>
getImageGicon :: (MonadIO m, IsImage o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #gicon <a>:=</a> value ]
--   </pre>
setImageGicon :: (MonadIO m, IsImage o, IsIcon a) => o -> a -> m ()

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearImageIconName :: (MonadIO m, IsImage o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageIconName :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #iconName
--   </pre>
getImageIconName :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #iconName <a>:=</a> value ]
--   </pre>
setImageIconName :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageIconSize :: (IsImage o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #iconSize
--   </pre>
getImageIconSize :: (MonadIO m, IsImage o) => o -> m IconSize

-- | Set the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #iconSize <a>:=</a> value ]
--   </pre>
setImageIconSize :: (MonadIO m, IsImage o) => o -> IconSize -> m ()

-- | Set the value of the “<tt>paintable</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #paintable
--   </pre>
clearImagePaintable :: (MonadIO m, IsImage o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>paintable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImagePaintable :: (IsImage o, MonadIO m, IsPaintable a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #paintable
--   </pre>
getImagePaintable :: (MonadIO m, IsImage o) => o -> m (Maybe Paintable)

-- | Set the value of the “<tt>paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #paintable <a>:=</a> value ]
--   </pre>
setImagePaintable :: (MonadIO m, IsImage o, IsPaintable a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixel-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImagePixelSize :: (IsImage o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixel-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #pixelSize
--   </pre>
getImagePixelSize :: (MonadIO m, IsImage o) => o -> m Int32

-- | Set the value of the “<tt>pixel-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #pixelSize <a>:=</a> value ]
--   </pre>
setImagePixelSize :: (MonadIO m, IsImage o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>resource</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #resource
--   </pre>
clearImageResource :: (MonadIO m, IsImage o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resource</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructImageResource :: (IsImage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #resource
--   </pre>
getImageResource :: (MonadIO m, IsImage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #resource <a>:=</a> value ]
--   </pre>
setImageResource :: (MonadIO m, IsImage o) => o -> Text -> m ()

-- | Get the value of the “<tt>storage-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #storageType
--   </pre>
getImageStorageType :: (MonadIO m, IsImage o) => o -> m ImageType

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-fallback</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructImageUseFallback :: (IsImage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> image #useFallback
--   </pre>
getImageUseFallback :: (MonadIO m, IsImage o) => o -> m Bool

-- | Set the value of the “<tt>use-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> image [ #useFallback <a>:=</a> value ]
--   </pre>
setImageUseFallback :: (MonadIO m, IsImage o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Image.Image
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Image.Image
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Image.Image
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Image.Image)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Image.Image o) => GI.Gtk.Objects.Image.IsImage o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Image.Image
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Image.Image


-- | <tt>GtkIconView</tt> is a widget which displays data in a grid of
--   icons.
--   
--   &lt;picture&gt; &lt;source srcset="icon-view-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkIconView" src="icon-view.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkIconView</tt> provides an alternative view on a
--   <tt>GtkTreeModel</tt>. It displays the model as a grid of icons with
--   labels. Like <a>TreeView</a>, it allows to select one or multiple
--   items (depending on the selection mode, see
--   <a>iconViewSetSelectionMode</a>). In addition to selection with the
--   arrow keys, <tt>GtkIconView</tt> supports rubberband selection, which
--   is controlled by dragging the pointer.
--   
--   Note that if the tree model is backed by an actual tree store (as
--   opposed to a flat list where the mapping to icons is obvious),
--   <tt>GtkIconView</tt> will only display the first level of the tree and
--   ignore the tree’s branches.
--   
--   <h2>CSS nodes</h2>
--   
--   <pre>
--   iconview.view
--   ╰── [rubberband]
--   </pre>
--   
--   <tt>GtkIconView</tt> has a single CSS node with name iconview and
--   style class .view. For rubberband selection, a subnode with name
--   rubberband is used.
module GI.Gtk.Objects.IconView

-- | Memory-managed wrapper type.
newtype IconView
IconView :: ManagedPtr IconView -> IconView

-- | Type class for types which can be safely cast to <a>IconView</a>, for
--   instance with <a>toIconView</a>.
class (GObject o, IsDescendantOf IconView o) => IsIconView o

-- | Cast to <a>IconView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toIconView :: (MonadIO m, IsIconView o) => o -> m IconView

-- | Creates a <tt>GdkPaintable</tt> representation of the item at
--   <i><tt>path</tt></i>. This image is used for a drag icon.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewCreateDragIcon :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m (Maybe Paintable)

-- | Turns <i><tt>iconView</tt></i> into a drop destination for automatic
--   DND. Calling this method sets <tt>GtkIconView</tt>:reorderable to
--   <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewEnableModelDragDest :: (HasCallStack, MonadIO m, IsIconView a) => a -> ContentFormats -> [DragAction] -> m ()

-- | Turns <i><tt>iconView</tt></i> into a drag source for automatic DND.
--   Calling this method sets <tt>GtkIconView</tt>:reorderable to
--   <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewEnableModelDragSource :: (HasCallStack, MonadIO m, IsIconView a) => a -> [ModifierType] -> ContentFormats -> [DragAction] -> m ()

-- | Gets the setting set by <a>iconViewSetActivateOnSingleClick</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Bool

-- | Fills the bounding rectangle in widget coordinates for the cell
--   specified by <i><tt>path</tt></i> and <i><tt>cell</tt></i>. If
--   <i><tt>cell</tt></i> is <a>Nothing</a> the main cell area is used.
--   
--   This function is only valid if <i><tt>iconView</tt></i> is realized.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetCellRect :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> m (Bool, Rectangle)

-- | Returns the value of the <a>columnSpacing</a> property.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetColumnSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the value of the <a>columns</a> property.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetColumns :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Fills in <i><tt>path</tt></i> and <i><tt>cell</tt></i> with the
--   current cursor path and cell. If the cursor isn’t currently set, then
--   *<i><tt>path</tt></i> will be <a>Nothing</a>. If no cell currently has
--   focus, then *<i><tt>cell</tt></i> will be <a>Nothing</a>.
--   
--   The returned <tt>GtkTreePath</tt> must be freed with
--   <a>treePathFree</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetCursor :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, CellRenderer)

-- | Determines the destination item for a given position.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetDestItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, IconViewDropPosition)

-- | Gets information about the item that is highlighted for feedback.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Maybe TreePath, IconViewDropPosition)

-- | Gets the path and cell for the icon at the given position.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetItemAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Bool, TreePath, CellRenderer)

-- | Gets the column in which the item <i><tt>path</tt></i> is currently
--   displayed. Column numbers start at 0.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetItemColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Int32

-- | Returns the value of the <a>itemOrientation</a> property which
--   determines whether the labels are drawn beside the icons instead of
--   below.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetItemOrientation :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Orientation

-- | Returns the value of the <a>itemPadding</a> property.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetItemPadding :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Gets the row in which the item <i><tt>path</tt></i> is currently
--   displayed. Row numbers start at 0.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetItemRow :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Int32

-- | Returns the value of the <a>itemWidth</a> property.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetItemWidth :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the value of the <a>margin</a> property.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetMargin :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column with markup text for <i><tt>iconView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetMarkupColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the model the <tt>GtkIconView</tt> is based on. Returns
--   <a>Nothing</a> if the model is unset.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetModel :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Maybe TreeModel)

-- | Gets the path for the icon at the given position.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetPathAtPos :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> m (Maybe TreePath)

-- | Returns the column with pixbufs for <i><tt>iconView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetPixbufColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Retrieves whether the user can reorder the list via drag-and-drop. See
--   <a>iconViewSetReorderable</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetReorderable :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Bool

-- | Returns the value of the <a>rowSpacing</a> property.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetRowSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Creates a list of paths of all selected items. Additionally, if you
--   are planning on modifying the model after calling this function, you
--   may want to convert the returned list into a list of
--   <tt>GtkTreeRowReferences</tt>. To do this, you can use
--   <a>treeRowReferenceNew</a>.
--   
--   To free the return value, use <tt>g_list_free_full</tt>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *icon_view = gtk_icon_view_new ();
--   // Use icon_view
--   
--   GList *list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (icon_view));
--   
--   // use list
--   
--   g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
--   </pre>

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetSelectedItems :: (HasCallStack, MonadIO m, IsIconView a) => a -> m [TreePath]

-- | Gets the selection mode of the <i><tt>iconView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetSelectionMode :: (HasCallStack, MonadIO m, IsIconView a) => a -> m SelectionMode

-- | Returns the value of the <a>spacing</a> property.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column with text for <i><tt>iconView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetTextColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | Returns the column of <i><tt>iconView</tt></i>’s model which is being
--   used for displaying tooltips on <i><tt>iconView</tt></i>’s rows.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetTooltipColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> m Int32

-- | This function is supposed to be used in a
--   <tt>GtkWidget::query-tooltip</tt> signal handler for
--   <tt>GtkIconView</tt>. The <i><tt>x</tt></i>, <i><tt>y</tt></i> and
--   <i><tt>keyboardTip</tt></i> values which are received in the signal
--   handler, should be passed to this function without modification.
--   
--   The return value indicates whether there is an icon view item at the
--   given coordinates (<a>True</a>) or not (<a>False</a>) for mouse
--   tooltips. For keyboard tooltips the item returned will be the cursor
--   item. When <a>True</a>, then any of <i><tt>model</tt></i>,
--   <i><tt>path</tt></i> and <i><tt>iter</tt></i> which have been provided
--   will be set to point to that row and the corresponding model.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetTooltipContext :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> Int32 -> Bool -> m (Bool, TreeModel, TreePath, TreeIter)

-- | Sets <i><tt>startPath</tt></i> and <i><tt>endPath</tt></i> to be the
--   first and last visible path. Note that there may be invisible paths in
--   between.
--   
--   Both paths should be freed with <a>treePathFree</a> after use.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewGetVisibleRange :: (HasCallStack, MonadIO m, IsIconView a) => a -> m (Bool, TreePath, TreePath)

-- | Activates the item determined by <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewItemActivated :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Creates a new <tt>GtkIconView</tt> widget

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewNew :: (HasCallStack, MonadIO m) => m IconView

-- | Creates a new <tt>GtkIconView</tt> widget using the specified
--   <i><tt>area</tt></i> to layout cells inside the icons.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m IconView

-- | Creates a new <tt>GtkIconView</tt> widget with the model
--   <i><tt>model</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m IconView

-- | Returns <a>True</a> if the icon pointed to by <i><tt>path</tt></i> is
--   currently selected. If <i><tt>path</tt></i> does not point to a valid
--   location, <a>False</a> is returned.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewPathIsSelected :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m Bool

-- | Moves the alignments of <i><tt>iconView</tt></i> to the position
--   specified by <i><tt>path</tt></i>. <i><tt>rowAlign</tt></i> determines
--   where the row is placed, and <i><tt>colAlign</tt></i> determines where
--   <i><tt>column</tt></i> is placed. Both are expected to be between 0.0
--   and 1.0. 0.0 means left/top alignment, 1.0 means right/bottom
--   alignment, 0.5 means center.
--   
--   If <i><tt>useAlign</tt></i> is <a>False</a>, then the alignment
--   arguments are ignored, and the tree does the minimum amount of work to
--   scroll the item onto the screen. This means that the item will be
--   scrolled to the edge closest to its current position. If the item is
--   currently visible on the screen, nothing is done.
--   
--   This function only works if the model is set, and <i><tt>path</tt></i>
--   is a valid row on the model. If the model changes before the
--   <i><tt>iconView</tt></i> is realized, the centered path will be
--   modified to reflect this change.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewScrollToPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> Bool -> Float -> Float -> m ()

-- | Selects all the icons. <i><tt>iconView</tt></i> must has its selection
--   mode set to <a>SelectionModeMultiple</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSelectAll :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Selects the row at <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSelectPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Calls a function for each selected icon. Note that the model or
--   selection cannot be modified from within this function.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSelectedForeach :: (HasCallStack, MonadIO m, IsIconView a) => a -> IconViewForeachFunc -> m ()

-- | Causes the <tt>GtkIconView</tt><a>itemActivated</a> signal to be
--   emitted on a single click instead of a double click.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsIconView a) => a -> Bool -> m ()

-- | Sets the <a>columnSpacing</a> property which specifies the space which
--   is inserted between the columns of the icon view.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetColumnSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the <a>columns</a> property which determines in how many columns
--   the icons are arranged. If <i><tt>columns</tt></i> is -1, the number
--   of columns will be chosen automatically to fill the available area.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetColumns :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the current keyboard focus to be at <i><tt>path</tt></i>, and
--   selects it. This is useful when you want to focus the user’s attention
--   on a particular item. If <i><tt>cell</tt></i> is not <a>Nothing</a>,
--   then focus is given to the cell specified by it. Additionally, if
--   <i><tt>startEditing</tt></i> is <a>True</a>, then editing should be
--   started in the specified cell.
--   
--   This function is often followed by <tt>gtk_widget_grab_focus
--   (icon_view)</tt> in order to give keyboard focus to the widget. Please
--   note that editing can only happen when the widget is realized.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetCursor :: (HasCallStack, MonadIO m, IsIconView a, IsCellRenderer b) => a -> TreePath -> Maybe b -> Bool -> m ()

-- | Sets the item that is highlighted for feedback.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetDragDestItem :: (HasCallStack, MonadIO m, IsIconView a) => a -> Maybe TreePath -> IconViewDropPosition -> m ()

-- | Sets the <a>itemOrientation</a> property which determines whether the
--   labels are drawn beside the icons instead of below.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetItemOrientation :: (HasCallStack, MonadIO m, IsIconView a) => a -> Orientation -> m ()

-- | Sets the <tt>GtkIconView</tt>:item-padding property which specifies
--   the padding around each of the icon view’s items.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetItemPadding :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the <a>itemWidth</a> property which specifies the width to use
--   for each item. If it is set to -1, the icon view will automatically
--   determine a suitable item size.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetItemWidth :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the <a>margin</a> property which specifies the space which is
--   inserted at the top, bottom, left and right of the icon view.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetMargin :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the column with markup information for <i><tt>iconView</tt></i>
--   to be <i><tt>column</tt></i>. The markup column must be of type
--   <tt>G_TYPE_STRING</tt>. If the markup column is set to something, it
--   overrides the text column set by <a>iconViewSetTextColumn</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetMarkupColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the model for a <tt>GtkIconView</tt>. If the
--   <i><tt>iconView</tt></i> already has a model set, it will remove it
--   before setting the new model. If <i><tt>model</tt></i> is
--   <a>Nothing</a>, then it will unset the old model.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetModel :: (HasCallStack, MonadIO m, IsIconView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Sets the column with pixbufs for <i><tt>iconView</tt></i> to be
--   <i><tt>column</tt></i>. The pixbuf column must be of type
--   <tt>GDK_TYPE_PIXBUF</tt>

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetPixbufColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | This function is a convenience function to allow you to reorder models
--   that support the <tt>GtkTreeDragSourceIface</tt> and the
--   <tt>GtkTreeDragDestIface</tt>. Both <tt>GtkTreeStore</tt> and
--   <tt>GtkListStore</tt> support these. If <i><tt>reorderable</tt></i> is
--   <a>True</a>, then the user can reorder the model by dragging and
--   dropping rows. The developer can listen to these changes by connecting
--   to the model's row_inserted and row_deleted signals. The reordering is
--   implemented by setting up the icon view as a drag source and
--   destination. Therefore, drag and drop can not be used in a reorderable
--   view for any other purpose.
--   
--   This function does not give you any degree of control over the order
--   -- any reordering is allowed. If more control is needed, you should
--   probably handle drag and drop manually.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetReorderable :: (HasCallStack, MonadIO m, IsIconView a) => a -> Bool -> m ()

-- | Sets the <a>rowSpacing</a> property which specifies the space which is
--   inserted between the rows of the icon view.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetRowSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the selection mode of the <i><tt>iconView</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetSelectionMode :: (HasCallStack, MonadIO m, IsIconView a) => a -> SelectionMode -> m ()

-- | Sets the <a>spacing</a> property which specifies the space which is
--   inserted between the cells (i.e. the icon and the text) of an item.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetSpacing :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the column with text for <i><tt>iconView</tt></i> to be
--   <i><tt>column</tt></i>. The text column must be of type
--   <tt>G_TYPE_STRING</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetTextColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to the area which
--   <i><tt>cell</tt></i> occupies in the item pointed to by
--   <i><tt>path</tt></i>. See also <a>tooltipSetTipArea</a>.
--   
--   See also <a>iconViewSetTooltipColumn</a> for a simpler alternative.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetTooltipCell :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b, IsCellRenderer c) => a -> b -> TreePath -> Maybe c -> m ()

-- | If you only plan to have simple (text-only) tooltips on full items,
--   you can use this function to have <tt>GtkIconView</tt> handle these
--   automatically for you. <i><tt>column</tt></i> should be set to the
--   column in <i><tt>iconView</tt></i>’s model containing the tooltip
--   texts, or -1 to disable this feature.
--   
--   When enabled, <tt>GtkWidget:has-tooltip</tt> will be set to
--   <a>True</a> and <i><tt>iconView</tt></i> will connect a
--   <tt>GtkWidget::query-tooltip</tt> signal handler.
--   
--   Note that the signal handler sets the text with
--   <a>tooltipSetMarkup</a>, so &amp;, &lt;, etc have to be escaped in the
--   text.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetTooltipColumn :: (HasCallStack, MonadIO m, IsIconView a) => a -> Int32 -> m ()

-- | Sets the tip area of <i><tt>tooltip</tt></i> to be the area covered by
--   the item at <i><tt>path</tt></i>. See also
--   <a>iconViewSetTooltipColumn</a> for a simpler alternative. See also
--   <a>tooltipSetTipArea</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewSetTooltipItem :: (HasCallStack, MonadIO m, IsIconView a, IsTooltip b) => a -> b -> TreePath -> m ()

-- | Unselects all the icons.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewUnselectAll :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Unselects the row at <i><tt>path</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewUnselectPath :: (HasCallStack, MonadIO m, IsIconView a) => a -> TreePath -> m ()

-- | Undoes the effect of <a>iconViewEnableModelDragDest</a>. Calling this
--   method sets <tt>GtkIconView</tt>:reorderable to <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewUnsetModelDragDest :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Undoes the effect of <a>iconViewEnableModelDragSource</a>. Calling
--   this method sets <tt>GtkIconView</tt>:reorderable to <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>GridView</a> instead</i>
iconViewUnsetModelDragSource :: (HasCallStack, MonadIO m, IsIconView a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructIconViewActivateOnSingleClick :: (IsIconView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #activateOnSingleClick
--   </pre>
getIconViewActivateOnSingleClick :: (MonadIO m, IsIconView o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setIconViewActivateOnSingleClick :: (MonadIO m, IsIconView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructIconViewCellArea :: (IsIconView o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #cellArea
--   </pre>
getIconViewCellArea :: (MonadIO m, IsIconView o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewColumnSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #columnSpacing
--   </pre>
getIconViewColumnSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #columnSpacing <a>:=</a> value ]
--   </pre>
setIconViewColumnSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>columns</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewColumns :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #columns
--   </pre>
getIconViewColumns :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #columns <a>:=</a> value ]
--   </pre>
setIconViewColumns :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>item-orientation</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewItemOrientation :: (IsIconView o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Get the value of the “<tt>item-orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #itemOrientation
--   </pre>
getIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> m Orientation

-- | Set the value of the “<tt>item-orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #itemOrientation <a>:=</a> value ]
--   </pre>
setIconViewItemOrientation :: (MonadIO m, IsIconView o) => o -> Orientation -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>item-padding</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewItemPadding :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>item-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #itemPadding
--   </pre>
getIconViewItemPadding :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>item-padding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #itemPadding <a>:=</a> value ]
--   </pre>
setIconViewItemPadding :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>item-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructIconViewItemWidth :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>item-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #itemWidth
--   </pre>
getIconViewItemWidth :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>item-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #itemWidth <a>:=</a> value ]
--   </pre>
setIconViewItemWidth :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>margin</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewMargin :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #margin
--   </pre>
getIconViewMargin :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>margin</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #margin <a>:=</a> value ]
--   </pre>
setIconViewMargin :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>markup-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewMarkupColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>markup-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #markupColumn
--   </pre>
getIconViewMarkupColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>markup-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #markupColumn <a>:=</a> value ]
--   </pre>
setIconViewMarkupColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearIconViewModel :: (MonadIO m, IsIconView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewModel :: (IsIconView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #model
--   </pre>
getIconViewModel :: (MonadIO m, IsIconView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #model <a>:=</a> value ]
--   </pre>
setIconViewModel :: (MonadIO m, IsIconView o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewPixbufColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixbuf-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #pixbufColumn
--   </pre>
getIconViewPixbufColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>pixbuf-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #pixbufColumn <a>:=</a> value ]
--   </pre>
setIconViewPixbufColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewReorderable :: (IsIconView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #reorderable
--   </pre>
getIconViewReorderable :: (MonadIO m, IsIconView o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #reorderable <a>:=</a> value ]
--   </pre>
setIconViewReorderable :: (MonadIO m, IsIconView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewRowSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #rowSpacing
--   </pre>
getIconViewRowSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #rowSpacing <a>:=</a> value ]
--   </pre>
setIconViewRowSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selection-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewSelectionMode :: (IsIconView o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #selectionMode
--   </pre>
getIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> m SelectionMode

-- | Set the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #selectionMode <a>:=</a> value ]
--   </pre>
setIconViewSelectionMode :: (MonadIO m, IsIconView o) => o -> SelectionMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIconViewSpacing :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #spacing
--   </pre>
getIconViewSpacing :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #spacing <a>:=</a> value ]
--   </pre>
setIconViewSpacing :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIconViewTextColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #textColumn
--   </pre>
getIconViewTextColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #textColumn <a>:=</a> value ]
--   </pre>
setIconViewTextColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tooltip-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructIconViewTooltipColumn :: (IsIconView o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iconView #tooltipColumn
--   </pre>
getIconViewTooltipColumn :: (MonadIO m, IsIconView o) => o -> m Int32

-- | Set the value of the “<tt>tooltip-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iconView [ #tooltipColumn <a>:=</a> value ]
--   </pre>
setIconViewTooltipColumn :: (MonadIO m, IsIconView o) => o -> Int32 -> m ()

-- | A [keybinding signal]t<a>SignalAction</a> which gets emitted when the
--   user activates the currently focused item.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   activation programmatically.
--   
--   The default bindings for this signal are Space, Return and Enter.
type IconViewActivateCursorItemCallback = IO Bool

-- | Connect a signal handler for the <a>activateCursorItem</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #activateCursorItem callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCursorItem</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #activateCursorItem callback
--   </pre>
onIconViewActivateCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewActivateCursorItemCallback) -> m SignalHandlerId

-- | The <a>itemActivated</a> signal is emitted when the method
--   <a>iconViewItemActivated</a> is called, when the user double clicks an
--   item with the "activate-on-single-click" property set to <a>False</a>,
--   or when the user single clicks an item when the
--   "activate-on-single-click" property set to <a>True</a>. It is also
--   emitted when a non-editable item is selected and one of the keys:
--   Space, Return or Enter is pressed.
type IconViewItemActivatedCallback = TreePath -> IO ()

-- | Connect a signal handler for the <a>itemActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #itemActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>itemActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #itemActivated callback
--   </pre>
onIconViewItemActivated :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewItemActivatedCallback) -> m SignalHandlerId

-- | The <a>moveCursor</a> signal is a [keybinding
--   signal]t<a>SignalAction</a> which gets emitted when the user initiates
--   a cursor movement.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control the
--   cursor programmatically.
--   
--   The default bindings for this signal include * Arrow keys which move
--   by individual steps * Home/End keys which move to the first/last item
--   * PageUp/PageDown which move by "pages" All of these will extend the
--   selection when combined with the Shift modifier.
type IconViewMoveCursorCallback = MovementStep -> Int32 -> Bool -> Bool -> IO Bool

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconView #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #moveCursor callback
--   </pre>
onIconViewMoveCursor :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewMoveCursorCallback) -> m SignalHandlerId

-- | A [keybinding signal]t<a>SignalAction</a> which gets emitted when the
--   user selects all items.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   The default binding for this signal is Ctrl-a.
type IconViewSelectAllCallback = IO ()

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconView #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #selectAll callback
--   </pre>
onIconViewSelectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectAllCallback) -> m SignalHandlerId

-- | A [keybinding signal]t<a>SignalAction</a> which gets emitted when the
--   user selects the item that is currently focused.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   There is no default binding for this signal.
type IconViewSelectCursorItemCallback = IO ()

-- | Connect a signal handler for the <a>selectCursorItem</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #selectCursorItem callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectCursorItem</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #selectCursorItem callback
--   </pre>
onIconViewSelectCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectCursorItemCallback) -> m SignalHandlerId

-- | The <a>selectionChanged</a> signal is emitted when the selection (i.e.
--   the set of selected items) changes.
type IconViewSelectionChangedCallback = IO ()

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #selectionChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectionChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #selectionChanged callback
--   </pre>
onIconViewSelectionChanged :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewSelectionChangedCallback) -> m SignalHandlerId

-- | A [keybinding signal]t<a>SignalAction</a> which gets emitted when the
--   user toggles whether the currently focused item is selected or not.
--   The exact effect of this depend on the selection mode.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   There is no default binding for this signal is Ctrl-Space.
type IconViewToggleCursorItemCallback = IO ()

-- | Connect a signal handler for the <a>toggleCursorItem</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iconView #toggleCursorItem callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorItem</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #toggleCursorItem callback
--   </pre>
onIconViewToggleCursorItem :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewToggleCursorItemCallback) -> m SignalHandlerId

-- | A [keybinding signal]t<a>SignalAction</a> which gets emitted when the
--   user unselects all items.
--   
--   Applications should not connect to it, but may emit it with
--   <tt><i>g_signal_emit_by_name()</i></tt> if they need to control
--   selection programmatically.
--   
--   The default binding for this signal is Ctrl-Shift-a.
type IconViewUnselectAllCallback = IO ()

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iconView #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iconView #unselectAll callback
--   </pre>
onIconViewUnselectAll :: (IsIconView a, MonadIO m) => a -> ((?self :: a) => IconViewUnselectAllCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.IconView.IconView
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.IconView.IconView
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.IconView.IconView
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.IconView.IconView)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.IconView.IconView o) => GI.Gtk.Objects.IconView.IsIconView o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.IconView.IconView
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.IconView.IconView


-- | Supports switching between multiple input methods.
--   
--   Text widgets such as <tt>GtkText</tt> or <tt>GtkTextView</tt> use a
--   <tt>GtkIMMultiContext</tt> to implement their <tt>im-module</tt>
--   property for switching between different input methods.
module GI.Gtk.Objects.IMMulticontext

-- | Memory-managed wrapper type.
newtype IMMulticontext
IMMulticontext :: ManagedPtr IMMulticontext -> IMMulticontext

-- | Type class for types which can be safely cast to
--   <a>IMMulticontext</a>, for instance with <a>toIMMulticontext</a>.
class (GObject o, IsDescendantOf IMMulticontext o) => IsIMMulticontext o

-- | Cast to <a>IMMulticontext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIMMulticontext :: (MonadIO m, IsIMMulticontext o) => o -> m IMMulticontext

-- | Gets the id of the currently active delegate of the
--   <i><tt>context</tt></i>.
iMMulticontextGetContextId :: (HasCallStack, MonadIO m, IsIMMulticontext a) => a -> m Text

-- | Creates a new <tt>GtkIMMulticontext</tt>.
iMMulticontextNew :: (HasCallStack, MonadIO m) => m IMMulticontext

-- | Sets the context id for <i><tt>context</tt></i>.
--   
--   This causes the currently active delegate of <i><tt>context</tt></i>
--   to be replaced by the delegate corresponding to the new context id.
--   
--   Setting this to a non-<a>Nothing</a> value overrides the system-wide
--   IM module setting. See the <a>Settings:gtkImModule</a> property.
iMMulticontextSetContextId :: (HasCallStack, MonadIO m, IsIMMulticontext a) => a -> Maybe Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.IMMulticontext.IMMulticontext
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.IMMulticontext.IMMulticontext
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.IMMulticontext.IMMulticontext
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.IMMulticontext.IMMulticontext)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.IMMulticontext.IMMulticontext o) => GI.Gtk.Objects.IMMulticontext.IsIMMulticontext o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.IMMulticontext.IMMulticontext
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.IMMulticontext.IMMulticontext


-- | Supports compose sequences, dead keys and numeric Unicode input.
--   
--   <h2>Compose sequences</h2>
--   
--   <tt>GtkIMContextSimple</tt> reads compose sequences from the first of
--   the following files that is found: ~/.config/gtk-4.0/Compose,
--   ~/.XCompose, /usr/share/X11/locale/$locale/Compose (for locales that
--   have a nontrivial Compose file). A subset of the file syntax described
--   in the Compose(5) manual page is supported. Additionally, <tt>include
--   "%L"</tt> loads GTK’s built-in table of compose sequences rather than
--   the locale-specific one from X11.
--   
--   If none of these files is found, <tt>GtkIMContextSimple</tt> uses a
--   built-in table of compose sequences that is derived from the X11
--   Compose files.
--   
--   Note that compose sequences typically start with the Compose_key,
--   which is often not available as a dedicated key on keyboards. Keyboard
--   layouts may map this keysym to other keys, such as the right Control
--   key.
--   
--   <h2>Unicode characters</h2>
--   
--   <tt>GtkIMContextSimple</tt> also supports numeric entry of Unicode
--   characters by typing
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;u&lt;/kbd&gt;,
--   followed by a hexadecimal Unicode codepoint.
--   
--   For example,
--   
--   Ctrl-Shift-u 1 2 3 Enter
--   
--   yields U+0123 LATIN SMALL LETTER G WITH CEDILLA, i.e. ģ.
--   
--   <h2>Dead keys</h2>
--   
--   <tt>GtkIMContextSimple</tt> supports dead keys. For example, typing
--   
--   dead_acute a
--   
--   yields U+00E! LATIN SMALL LETTER_A WITH ACUTE, i.e. á. Note that this
--   depends on the keyboard layout including dead keys.
module GI.Gtk.Objects.IMContextSimple

-- | Memory-managed wrapper type.
newtype IMContextSimple
IMContextSimple :: ManagedPtr IMContextSimple -> IMContextSimple

-- | Type class for types which can be safely cast to
--   <a>IMContextSimple</a>, for instance with <a>toIMContextSimple</a>.
class (GObject o, IsDescendantOf IMContextSimple o) => IsIMContextSimple o

-- | Cast to <a>IMContextSimple</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toIMContextSimple :: (MonadIO m, IsIMContextSimple o) => o -> m IMContextSimple

-- | Adds an additional table from the X11 compose file.
iMContextSimpleAddComposeFile :: (HasCallStack, MonadIO m, IsIMContextSimple a) => a -> Text -> m ()

-- | Creates a new <tt>GtkIMContextSimple</tt>.
iMContextSimpleNew :: (HasCallStack, MonadIO m) => m IMContextSimple
instance GHC.Classes.Eq GI.Gtk.Objects.IMContextSimple.IMContextSimple
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.IMContextSimple.IMContextSimple
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.IMContextSimple.IMContextSimple
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.IMContextSimple.IMContextSimple)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.IMContextSimple.IMContextSimple o) => GI.Gtk.Objects.IMContextSimple.IsIMContextSimple o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.IMContextSimple.IMContextSimple
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.IMContextSimple.IMContextSimple


-- | The interface for GTK input methods.
--   
--   <tt>GtkIMContext</tt> is used by GTK text input widgets like
--   <tt>GtkText</tt> to map from key events to Unicode character strings.
--   
--   An input method may consume multiple key events in sequence before
--   finally outputting the composed result. This is called *preediting*,
--   and an input method may provide feedback about this process by
--   displaying the intermediate composition states as preedit text. To do
--   so, the <tt>GtkIMContext</tt> will emit
--   <a>IMContext::preeditStart</a>, <a>IMContext::preeditChanged</a> and
--   <a>IMContext::preeditEnd</a> signals.
--   
--   For instance, the built-in GTK input method <a>IMContextSimple</a>
--   implements the input of arbitrary Unicode code points by holding down
--   the &lt;kbd&gt;Control&lt;/kbd&gt; and &lt;kbd&gt;Shift&lt;/kbd&gt;
--   keys and then typing &lt;kbd&gt;u&lt;/kbd&gt; followed by the
--   hexadecimal digits of the code point. When releasing the
--   &lt;kbd&gt;Control&lt;/kbd&gt; and &lt;kbd&gt;Shift&lt;/kbd&gt; keys,
--   preediting ends and the character is inserted as text. For example,
--   
--   Ctrl+Shift+u 2 0 A C
--   
--   results in the € sign.
--   
--   Additional input methods can be made available for use by GTK widgets
--   as loadable modules. An input method module is a small shared library
--   which provides a <tt>GIOExtension</tt> for the extension point named
--   "gtk-im-module".
--   
--   To connect a widget to the users preferred input method, you should
--   use <a>IMMulticontext</a>.
module GI.Gtk.Objects.IMContext

-- | Memory-managed wrapper type.
newtype IMContext
IMContext :: ManagedPtr IMContext -> IMContext

-- | Type class for types which can be safely cast to <a>IMContext</a>, for
--   instance with <a>toIMContext</a>.
class (GObject o, IsDescendantOf IMContext o) => IsIMContext o

-- | Cast to <a>IMContext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIMContext :: (MonadIO m, IsIMContext o) => o -> m IMContext

-- | Requests the platform to show an on-screen keyboard for user input.
--   
--   This method will return <a>True</a> if this request was actually
--   performed to the platform, other environmental factors may result in
--   an on-screen keyboard effectively not showing up.
--   
--   <i>Since: 4.14</i>
iMContextActivateOsk :: (HasCallStack, MonadIO m, IsIMContext a, IsEvent b) => a -> Maybe b -> m Bool

-- | Asks the widget that the input context is attached to delete
--   characters around the cursor position by emitting the
--   <tt>::delete_surrounding</tt> signal.
--   
--   Note that <i><tt>offset</tt></i> and <i><tt>nChars</tt></i> are in
--   characters not in bytes which differs from the usage other places in
--   <tt>GtkIMContext</tt>.
--   
--   In order to use this function, you should first call
--   <a>iMContextGetSurrounding</a> to get the current context, and call
--   this function immediately afterwards to make sure that you know what
--   you are deleting. You should also account for the fact that even if
--   the signal was handled, the input context might not have deleted all
--   the characters that were requested to be deleted.
--   
--   This function is used by an input method that wants to make
--   substitutions in the existing text in response to new input. It is not
--   useful for applications.
iMContextDeleteSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Int32 -> Int32 -> m Bool

-- | Allow an input method to forward key press and release events to
--   another input method without necessarily having a <tt>GdkEvent</tt>
--   available.
iMContextFilterKey :: (HasCallStack, MonadIO m, IsIMContext a, IsSurface b, IsDevice c) => a -> Bool -> b -> c -> Word32 -> Word32 -> [ModifierType] -> Int32 -> m Bool

-- | Allow an input method to internally handle key press and release
--   events.
--   
--   If this function returns <a>True</a>, then no further processing
--   should be done for this key event.
iMContextFilterKeypress :: (HasCallStack, MonadIO m, IsIMContext a, IsEvent b) => a -> b -> m Bool

-- | Notify the input method that the widget to which this input context
--   corresponds has gained focus.
--   
--   The input method may, for example, change the displayed feedback to
--   reflect this change.
iMContextFocusIn :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ()

-- | Notify the input method that the widget to which this input context
--   corresponds has lost focus.
--   
--   The input method may, for example, change the displayed feedback or
--   reset the contexts state to reflect this change.
iMContextFocusOut :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ()

-- | Retrieve the current preedit string for the input context, and a list
--   of attributes to apply to the string.
--   
--   This string should be displayed inserted at the insertion point.
iMContextGetPreeditString :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Text, AttrList, Int32)

-- | Retrieves context around the insertion point.
--   
--   Input methods typically want context in order to constrain input text
--   based on existing text; this is important for languages such as Thai
--   where only some sequences of characters are allowed.
--   
--   This function is implemented by emitting the
--   <a>IMContext::retrieveSurrounding</a> signal on the input method; in
--   response to this signal, a widget should provide as much context as is
--   available, up to an entire paragraph, by calling
--   <a>iMContextSetSurrounding</a>.
--   
--   Note that there is no obligation for a widget to respond to the
--   <tt>::retrieve-surrounding</tt> signal, so input methods must be
--   prepared to function without context.

-- | <i>Deprecated: (Since version 4.2)Use
--   <a>iMContextGetSurroundingWithSelection</a> instead.</i>
iMContextGetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Bool, Text, Int32)

-- | Retrieves context around the insertion point.
--   
--   Input methods typically want context in order to constrain input text
--   based on existing text; this is important for languages such as Thai
--   where only some sequences of characters are allowed.
--   
--   This function is implemented by emitting the
--   <a>IMContext::retrieveSurrounding</a> signal on the input method; in
--   response to this signal, a widget should provide as much context as is
--   available, up to an entire paragraph, by calling
--   <a>iMContextSetSurroundingWithSelection</a>.
--   
--   Note that there is no obligation for a widget to respond to the
--   <tt>::retrieve-surrounding</tt> signal, so input methods must be
--   prepared to function without context.
--   
--   <i>Since: 4.2</i>
iMContextGetSurroundingWithSelection :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m (Bool, Text, Int32, Int32)

-- | Notify the input method that a change such as a change in cursor
--   position has been made.
--   
--   This will typically cause the input method to clear the preedit state.
iMContextReset :: (HasCallStack, MonadIO m, IsIMContext a) => a -> m ()

-- | Set the client widget for the input context.
--   
--   This is the <tt>GtkWidget</tt> holding the input focus. This widget is
--   used in order to correctly position status windows, and may also be
--   used for purposes internal to the input method.
iMContextSetClientWidget :: (HasCallStack, MonadIO m, IsIMContext a, IsWidget b) => a -> Maybe b -> m ()

-- | Notify the input method that a change in cursor position has been
--   made.
--   
--   The location is relative to the client widget.
iMContextSetCursorLocation :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Rectangle -> m ()

-- | Sets surrounding context around the insertion point and preedit
--   string.
--   
--   This function is expected to be called in response to the
--   <a>IMContext::retrieveSurrounding</a> signal, and will likely have no
--   effect if called at other times.

-- | <i>Deprecated: (Since version 4.2)Use
--   <a>iMContextSetSurroundingWithSelection</a> instead</i>
iMContextSetSurrounding :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Text -> Int32 -> Int32 -> m ()

-- | Sets surrounding context around the insertion point and preedit
--   string. This function is expected to be called in response to the
--   <a>signal<i><tt>gtk</tt></i>.IMContext[retrieve_surrounding</a>]
--   signal, and will likely have no effect if called at other times.
--   
--   <i>Since: 4.2</i>
iMContextSetSurroundingWithSelection :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Text -> Int32 -> Int32 -> Int32 -> m ()

-- | Sets whether the IM context should use the preedit string to display
--   feedback.
--   
--   If <i><tt>usePreedit</tt></i> is <a>False</a> (default is
--   <a>True</a>), then the IM context may use some other method to display
--   feedback, such as displaying it in a child of the root window.
iMContextSetUsePreedit :: (HasCallStack, MonadIO m, IsIMContext a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIMContextInputHints :: (IsIMContext o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContext #inputHints
--   </pre>
getIMContextInputHints :: (MonadIO m, IsIMContext o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContext [ #inputHints <a>:=</a> value ]
--   </pre>
setIMContextInputHints :: (MonadIO m, IsIMContext o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructIMContextInputPurpose :: (IsIMContext o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> iMContext #inputPurpose
--   </pre>
getIMContextInputPurpose :: (MonadIO m, IsIMContext o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> iMContext [ #inputPurpose <a>:=</a> value ]
--   </pre>
setIMContextInputPurpose :: (MonadIO m, IsIMContext o) => o -> InputPurpose -> m ()

-- | The <a>commit</a> signal is emitted when a complete input sequence has
--   been entered by the user.
--   
--   If the commit comes after a preediting sequence, the <a>commit</a>
--   signal is emitted after <a>preeditEnd</a>.
--   
--   This can be a single character immediately after a key press or the
--   final result of preediting.
type IMContextCommitCallback = Text -> IO ()

-- | Connect a signal handler for the <a>commit</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #commit callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextCommit :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextCommitCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>commit</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #commit callback
--   </pre>
onIMContextCommit :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextCommitCallback) -> m SignalHandlerId

-- | The <a>deleteSurrounding</a> signal is emitted when the input method
--   needs to delete all or part of the context surrounding the cursor.
type IMContextDeleteSurroundingCallback = Int32 -> Int32 -> IO Bool

-- | Connect a signal handler for the <a>deleteSurrounding</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #deleteSurrounding callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextDeleteSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextDeleteSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteSurrounding</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #deleteSurrounding callback
--   </pre>
onIMContextDeleteSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextDeleteSurroundingCallback) -> m SignalHandlerId

-- | Emitted when the filtered keys do not compose to a single valid
--   character.
--   
--   <i>Since: 4.22</i>
type IMContextInvalidCompositionCallback = Text -> IO Bool

-- | Connect a signal handler for the <a>invalidComposition</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #invalidComposition callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextInvalidComposition :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextInvalidCompositionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>invalidComposition</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #invalidComposition callback
--   </pre>
onIMContextInvalidComposition :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextInvalidCompositionCallback) -> m SignalHandlerId

-- | The <a>preeditChanged</a> signal is emitted whenever the preedit
--   sequence currently being entered has changed.
--   
--   It is also emitted at the end of a preedit sequence, in which case
--   <a>iMContextGetPreeditString</a> returns the empty string.
type IMContextPreeditChangedCallback = IO ()

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #preeditChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextPreeditChanged :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditChanged</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #preeditChanged callback
--   </pre>
onIMContextPreeditChanged :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditChangedCallback) -> m SignalHandlerId

-- | The <a>preeditEnd</a> signal is emitted when a preediting sequence has
--   been completed or canceled.
type IMContextPreeditEndCallback = IO ()

-- | Connect a signal handler for the <a>preeditEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #preeditEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextPreeditEnd :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #preeditEnd callback
--   </pre>
onIMContextPreeditEnd :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditEndCallback) -> m SignalHandlerId

-- | The <a>preeditStart</a> signal is emitted when a new preediting
--   sequence starts.
type IMContextPreeditStartCallback = IO ()

-- | Connect a signal handler for the <a>preeditStart</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #preeditStart callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextPreeditStart :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditStartCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>preeditStart</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #preeditStart callback
--   </pre>
onIMContextPreeditStart :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextPreeditStartCallback) -> m SignalHandlerId

-- | The <a>retrieveSurrounding</a> signal is emitted when the input method
--   requires the context surrounding the cursor.
--   
--   The callback should set the input method surrounding context by
--   calling the <a>iMContextSetSurrounding</a> method.
type IMContextRetrieveSurroundingCallback = IO Bool

-- | Connect a signal handler for the <a>retrieveSurrounding</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> iMContext #retrieveSurrounding callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterIMContextRetrieveSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextRetrieveSurroundingCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>retrieveSurrounding</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> iMContext #retrieveSurrounding callback
--   </pre>
onIMContextRetrieveSurrounding :: (IsIMContext a, MonadIO m) => a -> ((?self :: a) => IMContextRetrieveSurroundingCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.IMContext.IMContext
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.IMContext.IMContext
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.IMContext.IMContext
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.IMContext.IMContext)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.IMContext.IMContext o) => GI.Gtk.Objects.IMContext.IsIMContext o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.IMContext.IMContext
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.IMContext.IMContext


-- | Creates a custom titlebar for a window.
--   
--   &lt;picture&gt; &lt;source srcset="headerbar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkHeaderBar" src="headerbar.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkHeaderBar</tt> is similar to a horizontal
--   <tt>GtkCenterBox</tt>. It allows children to be placed at the start or
--   the end. In addition, it allows the window title to be displayed. The
--   title will be centered with respect to the width of the box, even if
--   the children at either side take up different amounts of space.
--   
--   <tt>GtkHeaderBar</tt> can add typical window frame controls, such as
--   minimize, maximize and close buttons, or the window icon.
--   
--   For these reasons, <tt>GtkHeaderBar</tt> is the natural choice for use
--   as the custom titlebar widget of a <tt>GtkWindow</tt> (see
--   <a>windowSetTitlebar</a>), as it gives features typical of titlebars
--   while allowing the addition of child widgets.
--   
--   <h2>GtkHeaderBar as GtkBuildable</h2>
--   
--   The <tt>GtkHeaderBar</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports adding children at the start or end sides by
--   specifying “start” or “end” as the “type” attribute of a
--   <tt>&lt;child&gt;</tt> element, or setting the title widget by
--   specifying “title” value.
--   
--   By default the <tt>GtkHeaderBar</tt> uses a <tt>GtkLabel</tt>
--   displaying the title of the window it is contained in as the title
--   widget, equivalent to the following UI definition:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkHeaderBar"&gt;
--     &lt;property name="title-widget"&gt;
--       &lt;object class="GtkLabel"&gt;
--         &lt;property name="label" translatable="yes"&gt;Label&lt;/property&gt;
--         &lt;property name="single-line-mode"&gt;True&lt;/property&gt;
--         &lt;property name="ellipsize"&gt;end&lt;/property&gt;
--         &lt;property name="width-chars"&gt;5&lt;/property&gt;
--         &lt;style&gt;
--           &lt;class name="title"/&gt;
--         &lt;/style&gt;
--       &lt;/object&gt;
--     &lt;/property&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   headerbar
--   ╰── windowhandle
--       ╰── box
--           ├── box.start
--           │   ├── windowcontrols.start
--           │   ╰── [other children]
--           ├── [Title Widget]
--           ╰── box.end
--               ├── [other children]
--               ╰── windowcontrols.end
--   </pre>
--   
--   A <tt>GtkHeaderBar</tt>'s CSS node is called <tt>headerbar</tt>. It
--   contains a <tt>windowhandle</tt> subnode, which contains a
--   <tt>box</tt> subnode, which contains two <tt>box</tt> subnodes at the
--   start and end of the header bar, as well as a center node that
--   represents the title.
--   
--   Each of the boxes contains a <tt>windowcontrols</tt> subnode, see
--   <a>WindowControls</a> for details, as well as other children.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkHeaderBar</tt> uses the <a>AccessibleRoleGroup</a> role.
module GI.Gtk.Objects.HeaderBar

-- | Memory-managed wrapper type.
newtype HeaderBar
HeaderBar :: ManagedPtr HeaderBar -> HeaderBar

-- | Type class for types which can be safely cast to <a>HeaderBar</a>, for
--   instance with <a>toHeaderBar</a>.
class (GObject o, IsDescendantOf HeaderBar o) => IsHeaderBar o

-- | Cast to <a>HeaderBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toHeaderBar :: (MonadIO m, IsHeaderBar o) => o -> m HeaderBar

-- | Gets the decoration layout of the header bar.
headerBarGetDecorationLayout :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Text)

-- | Returns whether this header bar shows the standard window title
--   buttons.
headerBarGetShowTitleButtons :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m Bool

-- | Retrieves the title widget of the header bar.
--   
--   See <a>headerBarSetTitleWidget</a>.
headerBarGetTitleWidget :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m (Maybe Widget)

-- | Returns whether this header bar shows platform native window controls.
--   
--   <i>Since: 4.18</i>
headerBarGetUseNativeControls :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> m Bool

-- | Creates a new <tt>GtkHeaderBar</tt> widget.
headerBarNew :: (HasCallStack, MonadIO m) => m HeaderBar

-- | Adds a child to the header bar, packed with reference to the end.
headerBarPackEnd :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> b -> m ()

-- | Adds a child to the header bar, packed with reference to the start.
headerBarPackStart :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> b -> m ()

-- | Removes a child from the header bar.
--   
--   The child must have been added with <a>headerBarPackStart</a>,
--   <a>headerBarPackEnd</a> or <a>headerBarSetTitleWidget</a>.
headerBarRemove :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> b -> m ()

-- | Sets the decoration layout for this header bar.
--   
--   This property overrides the <a>Settings:gtkDecorationLayout</a>
--   setting.
--   
--   There can be valid reasons for overriding the setting, such as a
--   header bar design that does not allow for buttons to take room on the
--   right, or only offers room for a single close button. Split header
--   bars are another example for overriding the setting.
--   
--   The format of the string is button names, separated by commas. A colon
--   separates the buttons that should appear on the left from those on the
--   right. Recognized button names are minimize, maximize, close and icon
--   (the window icon).
--   
--   For example, “icon:minimize,maximize,close” specifies an icon on the
--   left, and minimize, maximize and close buttons on the right.
headerBarSetDecorationLayout :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Maybe Text -> m ()

-- | Sets whether this header bar shows the standard window title buttons.
headerBarSetShowTitleButtons :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Bool -> m ()

-- | Sets the title for the header bar.
--   
--   When set to <tt>NULL</tt>, the headerbar will display the title of the
--   window it is contained in.
--   
--   The title should help a user identify the current view. To achieve the
--   same style as the builtin title, use the “title” style class.
--   
--   You should set the title widget to <tt>NULL</tt>, for the window title
--   label to be visible again.
headerBarSetTitleWidget :: (HasCallStack, MonadIO m, IsHeaderBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether this header bar shows native window controls.
--   
--   This option shows the "stoplight" buttons on macOS. For Linux, this
--   option has no effect.
--   
--   See also <a>Using GTK on Apple macOS</a>.
--   
--   <i>Since: 4.18</i>
headerBarSetUseNativeControls :: (HasCallStack, MonadIO m, IsHeaderBar a) => a -> Bool -> m ()

-- | Set the value of the “<tt>decoration-layout</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #decorationLayout
--   </pre>
clearHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>decoration-layout</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructHeaderBarDecorationLayout :: (IsHeaderBar o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #decorationLayout
--   </pre>
getHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>decoration-layout</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #decorationLayout <a>:=</a> value ]
--   </pre>
setHeaderBarDecorationLayout :: (MonadIO m, IsHeaderBar o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-title-buttons</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructHeaderBarShowTitleButtons :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-title-buttons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #showTitleButtons
--   </pre>
getHeaderBarShowTitleButtons :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “<tt>show-title-buttons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #showTitleButtons <a>:=</a> value ]
--   </pre>
setHeaderBarShowTitleButtons :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()

-- | Set the value of the “<tt>title-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #titleWidget
--   </pre>
clearHeaderBarTitleWidget :: (MonadIO m, IsHeaderBar o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructHeaderBarTitleWidget :: (IsHeaderBar o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>title-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #titleWidget
--   </pre>
getHeaderBarTitleWidget :: (MonadIO m, IsHeaderBar o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>title-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #titleWidget <a>:=</a> value ]
--   </pre>
setHeaderBarTitleWidget :: (MonadIO m, IsHeaderBar o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-native-controls</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructHeaderBarUseNativeControls :: (IsHeaderBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-native-controls</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> headerBar #useNativeControls
--   </pre>
getHeaderBarUseNativeControls :: (MonadIO m, IsHeaderBar o) => o -> m Bool

-- | Set the value of the “<tt>use-native-controls</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> headerBar [ #useNativeControls <a>:=</a> value ]
--   </pre>
setHeaderBarUseNativeControls :: (MonadIO m, IsHeaderBar o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.HeaderBar.HeaderBar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.HeaderBar.HeaderBar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.HeaderBar.HeaderBar
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.HeaderBar.HeaderBar)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.HeaderBar.HeaderBar o) => GI.Gtk.Objects.HeaderBar.IsHeaderBar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.HeaderBar.HeaderBar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.HeaderBar.HeaderBar


-- | Presents a large dynamic grid of items.
--   
--   <tt>GtkGridView</tt> uses its factory to generate one child widget for
--   each visible item and shows them in a grid. The orientation of the
--   grid view determines if the grid reflows vertically or horizontally.
--   
--   <tt>GtkGridView</tt> allows the user to select items according to the
--   selection characteristics of the model. For models that allow multiple
--   selected items, it is possible to turn on _rubberband selection_,
--   using <a>GridView:enableRubberband</a>.
--   
--   To learn more about the list widget framework, see the
--   <a>overview</a>.
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkGridView</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>list.activate-item</tt> activates the item at given position
--   by emitting the the <a>GridView::activate</a> signal.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   gridview
--   ├── child[.activatable]
--   │
--   ├── child[.activatable]
--   │
--   ┊
--   ╰── [rubberband]
--   </pre>
--   
--   <tt>GtkGridView</tt> uses a single CSS node with name
--   <tt>gridview</tt>. Each child uses a single CSS node with name
--   <tt>child</tt>. If the <a>ListItem:activatable</a> property is set,
--   the corresponding row will have the <tt>.activatable</tt> style class.
--   For rubberband selection, a subnode with name <tt>rubberband</tt> is
--   used.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkGridView</tt> uses the <a>AccessibleRoleGrid</a> role, and the
--   items use the <a>AccessibleRoleGridCell</a> role.
module GI.Gtk.Objects.GridView

-- | Memory-managed wrapper type.
newtype GridView
GridView :: ManagedPtr GridView -> GridView

-- | Type class for types which can be safely cast to <a>GridView</a>, for
--   instance with <a>toGridView</a>.
class (GObject o, IsDescendantOf GridView o) => IsGridView o

-- | Cast to <a>GridView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toGridView :: (MonadIO m, IsGridView o) => o -> m GridView

-- | Returns whether rows can be selected by dragging with the mouse.
gridViewGetEnableRubberband :: (HasCallStack, MonadIO m, IsGridView a) => a -> m Bool

-- | Gets the factory that's currently used to populate list items.
gridViewGetFactory :: (HasCallStack, MonadIO m, IsGridView a) => a -> m (Maybe ListItemFactory)

-- | Gets the maximum number of columns that the grid will use.
gridViewGetMaxColumns :: (HasCallStack, MonadIO m, IsGridView a) => a -> m Word32

-- | Gets the minimum number of columns that the grid will use.
gridViewGetMinColumns :: (HasCallStack, MonadIO m, IsGridView a) => a -> m Word32

-- | Gets the model that's currently used to read the items displayed.
gridViewGetModel :: (HasCallStack, MonadIO m, IsGridView a) => a -> m (Maybe SelectionModel)

-- | Returns whether items will be activated on single click and selected
--   on hover.
gridViewGetSingleClickActivate :: (HasCallStack, MonadIO m, IsGridView a) => a -> m Bool

-- | Gets the behavior set for the &lt;kbd&gt;Tab&lt;/kbd&gt; key.
--   
--   <i>Since: 4.12</i>
gridViewGetTabBehavior :: (HasCallStack, MonadIO m, IsGridView a) => a -> m ListTabBehavior

-- | Creates a new <tt>GtkGridView</tt> that uses the given
--   <i><tt>factory</tt></i> for mapping items to widgets.
--   
--   The function takes ownership of the arguments, so you can write code
--   like
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   grid_view = gtk_grid_view_new (create_model (),
--     gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
--   </pre>
gridViewNew :: (HasCallStack, MonadIO m, IsSelectionModel a, IsListItemFactory b) => Maybe a -> Maybe b -> m GridView

-- | Scrolls to the item at the given position and performs the actions
--   specified in <i><tt>flags</tt></i>.
--   
--   This function works no matter if the gridview is shown or focused. If
--   it isn't, then the changes will take effect once that happens.
--   
--   <i>Since: 4.12</i>
gridViewScrollTo :: (HasCallStack, MonadIO m, IsGridView a) => a -> Word32 -> [ListScrollFlags] -> Maybe ScrollInfo -> m ()

-- | Sets whether selections can be changed by dragging with the mouse.
gridViewSetEnableRubberband :: (HasCallStack, MonadIO m, IsGridView a) => a -> Bool -> m ()

-- | Sets the <tt>GtkListItemFactory</tt> to use for populating list items.
gridViewSetFactory :: (HasCallStack, MonadIO m, IsGridView a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the maximum number of columns to use.
--   
--   This number must be at least 1.
--   
--   If <i><tt>maxColumns</tt></i> is smaller than the minimum set via
--   <a>gridViewSetMinColumns</a>, that value is used instead.
gridViewSetMaxColumns :: (HasCallStack, MonadIO m, IsGridView a) => a -> Word32 -> m ()

-- | Sets the minimum number of columns to use.
--   
--   This number must be at least 1.
--   
--   If <i><tt>minColumns</tt></i> is smaller than the minimum set via
--   <a>gridViewSetMaxColumns</a>, that value is ignored.
gridViewSetMinColumns :: (HasCallStack, MonadIO m, IsGridView a) => a -> Word32 -> m ()

-- | Sets the model to use.
--   
--   This must be a <a>SelectionModel</a>.
gridViewSetModel :: (HasCallStack, MonadIO m, IsGridView a, IsSelectionModel b) => a -> Maybe b -> m ()

-- | Sets whether items should be activated on single click and selected on
--   hover.
gridViewSetSingleClickActivate :: (HasCallStack, MonadIO m, IsGridView a) => a -> Bool -> m ()

-- | Sets the behavior of the &lt;kbd&gt;Tab&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; keys.
--   
--   <i>Since: 4.12</i>
gridViewSetTabBehavior :: (HasCallStack, MonadIO m, IsGridView a) => a -> ListTabBehavior -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-rubberband</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGridViewEnableRubberband :: (IsGridView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-rubberband</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridView #enableRubberband
--   </pre>
getGridViewEnableRubberband :: (MonadIO m, IsGridView o) => o -> m Bool

-- | Set the value of the “<tt>enable-rubberband</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridView [ #enableRubberband <a>:=</a> value ]
--   </pre>
setGridViewEnableRubberband :: (MonadIO m, IsGridView o) => o -> Bool -> m ()

-- | Set the value of the “<tt>factory</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #factory
--   </pre>
clearGridViewFactory :: (MonadIO m, IsGridView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>factory</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGridViewFactory :: (IsGridView o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridView #factory
--   </pre>
getGridViewFactory :: (MonadIO m, IsGridView o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridView [ #factory <a>:=</a> value ]
--   </pre>
setGridViewFactory :: (MonadIO m, IsGridView o, IsListItemFactory a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-columns</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridViewMaxColumns :: (IsGridView o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridView #maxColumns
--   </pre>
getGridViewMaxColumns :: (MonadIO m, IsGridView o) => o -> m Word32

-- | Set the value of the “<tt>max-columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridView [ #maxColumns <a>:=</a> value ]
--   </pre>
setGridViewMaxColumns :: (MonadIO m, IsGridView o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-columns</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridViewMinColumns :: (IsGridView o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridView #minColumns
--   </pre>
getGridViewMinColumns :: (MonadIO m, IsGridView o) => o -> m Word32

-- | Set the value of the “<tt>min-columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridView [ #minColumns <a>:=</a> value ]
--   </pre>
setGridViewMinColumns :: (MonadIO m, IsGridView o) => o -> Word32 -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearGridViewModel :: (MonadIO m, IsGridView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGridViewModel :: (IsGridView o, MonadIO m, IsSelectionModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridView #model
--   </pre>
getGridViewModel :: (MonadIO m, IsGridView o) => o -> m (Maybe SelectionModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridView [ #model <a>:=</a> value ]
--   </pre>
setGridViewModel :: (MonadIO m, IsGridView o, IsSelectionModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>single-click-activate</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructGridViewSingleClickActivate :: (IsGridView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>single-click-activate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridView #singleClickActivate
--   </pre>
getGridViewSingleClickActivate :: (MonadIO m, IsGridView o) => o -> m Bool

-- | Set the value of the “<tt>single-click-activate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridView [ #singleClickActivate <a>:=</a> value ]
--   </pre>
setGridViewSingleClickActivate :: (MonadIO m, IsGridView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-behavior</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridViewTabBehavior :: (IsGridView o, MonadIO m) => ListTabBehavior -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridView #tabBehavior
--   </pre>
getGridViewTabBehavior :: (MonadIO m, IsGridView o) => o -> m ListTabBehavior

-- | Set the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridView [ #tabBehavior <a>:=</a> value ]
--   </pre>
setGridViewTabBehavior :: (MonadIO m, IsGridView o) => o -> ListTabBehavior -> m ()

-- | Emitted when a cell has been activated by the user, usually via
--   activating the GtkGridView|list.activate-item action.
--   
--   This allows for a convenient way to handle activation in a gridview.
--   See <a>ListItem:activatable</a> for details on how to use this signal.
type GridViewActivateCallback = Word32 -> IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gridView #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGridViewActivate :: (IsGridView a, MonadIO m) => a -> ((?self :: a) => GridViewActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gridView #activate callback
--   </pre>
onGridViewActivate :: (IsGridView a, MonadIO m) => a -> ((?self :: a) => GridViewActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GridView.GridView
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GridView.GridView
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GridView.GridView
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GridView.GridView)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GridView.GridView o) => GI.Gtk.Objects.GridView.IsGridView o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GridView.GridView
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GridView.GridView


-- | <tt>GtkLayoutChild</tt> subclass for children in a
--   <tt>GtkGridLayout</tt>.
module GI.Gtk.Objects.GridLayoutChild

-- | Memory-managed wrapper type.
newtype GridLayoutChild
GridLayoutChild :: ManagedPtr GridLayoutChild -> GridLayoutChild

-- | Type class for types which can be safely cast to
--   <a>GridLayoutChild</a>, for instance with <a>toGridLayoutChild</a>.
class (GObject o, IsDescendantOf GridLayoutChild o) => IsGridLayoutChild o

-- | Cast to <a>GridLayoutChild</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toGridLayoutChild :: (MonadIO m, IsGridLayoutChild o) => o -> m GridLayoutChild

-- | Retrieves the column number to which <i><tt>child</tt></i> attaches
--   its left side.
gridLayoutChildGetColumn :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> m Int32

-- | Retrieves the number of columns that <i><tt>child</tt></i> spans to.
gridLayoutChildGetColumnSpan :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> m Int32

-- | Retrieves the row number to which <i><tt>child</tt></i> attaches its
--   top side.
gridLayoutChildGetRow :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> m Int32

-- | Retrieves the number of rows that <i><tt>child</tt></i> spans to.
gridLayoutChildGetRowSpan :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> m Int32

-- | Sets the column number to attach the left side of
--   <i><tt>child</tt></i>.
gridLayoutChildSetColumn :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> Int32 -> m ()

-- | Sets the number of columns <i><tt>child</tt></i> spans to.
gridLayoutChildSetColumnSpan :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> Int32 -> m ()

-- | Sets the row to place <i><tt>child</tt></i> in.
gridLayoutChildSetRow :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> Int32 -> m ()

-- | Sets the number of rows <i><tt>child</tt></i> spans to.
gridLayoutChildSetRowSpan :: (HasCallStack, MonadIO m, IsGridLayoutChild a) => a -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGridLayoutChildColumn :: (IsGridLayoutChild o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayoutChild #column
--   </pre>
getGridLayoutChildColumn :: (MonadIO m, IsGridLayoutChild o) => o -> m Int32

-- | Set the value of the “<tt>column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayoutChild [ #column <a>:=</a> value ]
--   </pre>
setGridLayoutChildColumn :: (MonadIO m, IsGridLayoutChild o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-span</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridLayoutChildColumnSpan :: (IsGridLayoutChild o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-span</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayoutChild #columnSpan
--   </pre>
getGridLayoutChildColumnSpan :: (MonadIO m, IsGridLayoutChild o) => o -> m Int32

-- | Set the value of the “<tt>column-span</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayoutChild [ #columnSpan <a>:=</a> value ]
--   </pre>
setGridLayoutChildColumnSpan :: (MonadIO m, IsGridLayoutChild o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGridLayoutChildRow :: (IsGridLayoutChild o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayoutChild #row
--   </pre>
getGridLayoutChildRow :: (MonadIO m, IsGridLayoutChild o) => o -> m Int32

-- | Set the value of the “<tt>row</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayoutChild [ #row <a>:=</a> value ]
--   </pre>
setGridLayoutChildRow :: (MonadIO m, IsGridLayoutChild o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-span</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGridLayoutChildRowSpan :: (IsGridLayoutChild o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-span</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayoutChild #rowSpan
--   </pre>
getGridLayoutChildRowSpan :: (MonadIO m, IsGridLayoutChild o) => o -> m Int32

-- | Set the value of the “<tt>row-span</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayoutChild [ #rowSpan <a>:=</a> value ]
--   </pre>
setGridLayoutChildRowSpan :: (MonadIO m, IsGridLayoutChild o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.GridLayoutChild.GridLayoutChild
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GridLayoutChild.GridLayoutChild
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GridLayoutChild.GridLayoutChild
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GridLayoutChild.GridLayoutChild)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GridLayoutChild.GridLayoutChild o) => GI.Gtk.Objects.GridLayoutChild.IsGridLayoutChild o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GridLayoutChild.GridLayoutChild
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GridLayoutChild.GridLayoutChild


-- | Arranges child widgets in rows and columns.
--   
--   Children have an "attach point" defined by the horizontal and vertical
--   index of the cell they occupy; children can span multiple rows or
--   columns. The layout properties for setting the attach points and spans
--   are set using the <a>GridLayoutChild</a> associated to each child
--   widget.
--   
--   The behaviour of <tt>GtkGridLayout</tt> when several children occupy
--   the same grid cell is undefined.
--   
--   <tt>GtkGridLayout</tt> can be used like a <tt>GtkBoxLayout</tt> if all
--   children are attached to the same row or column; however, if you only
--   ever need a single row or column, you should consider using
--   <tt>GtkBoxLayout</tt>.
module GI.Gtk.Objects.GridLayout

-- | Memory-managed wrapper type.
newtype GridLayout
GridLayout :: ManagedPtr GridLayout -> GridLayout

-- | Type class for types which can be safely cast to <a>GridLayout</a>,
--   for instance with <a>toGridLayout</a>.
class (GObject o, IsDescendantOf GridLayout o) => IsGridLayout o

-- | Cast to <a>GridLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGridLayout :: (MonadIO m, IsGridLayout o) => o -> m GridLayout

-- | Retrieves the row set with <a>gridLayoutSetBaselineRow</a>.
gridLayoutGetBaselineRow :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> m Int32

-- | Checks whether all columns of <i><tt>grid</tt></i> should have the
--   same width.
gridLayoutGetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> m Bool

-- | Retrieves the spacing set with <a>gridLayoutSetColumnSpacing</a>.
gridLayoutGetColumnSpacing :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> m Word32

-- | Returns the baseline position of <i><tt>row</tt></i>.
--   
--   If no value has been set with <a>gridLayoutSetRowBaselinePosition</a>,
--   the default value of <a>BaselinePositionCenter</a> is returned.
gridLayoutGetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> Int32 -> m BaselinePosition

-- | Checks whether all rows of <i><tt>grid</tt></i> should have the same
--   height.
gridLayoutGetRowHomogeneous :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> m Bool

-- | Retrieves the spacing set with <a>gridLayoutSetRowSpacing</a>.
gridLayoutGetRowSpacing :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> m Word32

-- | Creates a new <tt>GtkGridLayout</tt>.
gridLayoutNew :: (HasCallStack, MonadIO m) => m GridLayout

-- | Sets which row defines the global baseline for the entire grid.
--   
--   Each row in the grid can have its own local baseline, but only one of
--   those is global, meaning it will be the baseline in the parent of the
--   <i><tt>grid</tt></i>.
gridLayoutSetBaselineRow :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> Int32 -> m ()

-- | Sets whether all columns of <i><tt>grid</tt></i> should have the same
--   width.
gridLayoutSetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> Bool -> m ()

-- | Sets the amount of space to insert between consecutive columns.
gridLayoutSetColumnSpacing :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> Word32 -> m ()

-- | Sets how the baseline should be positioned on <i><tt>row</tt></i> of
--   the grid, in case that row is assigned more space than is requested.
gridLayoutSetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> Int32 -> BaselinePosition -> m ()

-- | Sets whether all rows of <i><tt>grid</tt></i> should have the same
--   height.
gridLayoutSetRowHomogeneous :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> Bool -> m ()

-- | Sets the amount of space to insert between consecutive rows.
gridLayoutSetRowSpacing :: (HasCallStack, MonadIO m, IsGridLayout a) => a -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-row</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridLayoutBaselineRow :: (IsGridLayout o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayout #baselineRow
--   </pre>
getGridLayoutBaselineRow :: (MonadIO m, IsGridLayout o) => o -> m Int32

-- | Set the value of the “<tt>baseline-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayout [ #baselineRow <a>:=</a> value ]
--   </pre>
setGridLayoutBaselineRow :: (MonadIO m, IsGridLayout o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-homogeneous</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructGridLayoutColumnHomogeneous :: (IsGridLayout o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayout #columnHomogeneous
--   </pre>
getGridLayoutColumnHomogeneous :: (MonadIO m, IsGridLayout o) => o -> m Bool

-- | Set the value of the “<tt>column-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayout [ #columnHomogeneous <a>:=</a> value ]
--   </pre>
setGridLayoutColumnHomogeneous :: (MonadIO m, IsGridLayout o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGridLayoutColumnSpacing :: (IsGridLayout o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayout #columnSpacing
--   </pre>
getGridLayoutColumnSpacing :: (MonadIO m, IsGridLayout o) => o -> m Int32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayout [ #columnSpacing <a>:=</a> value ]
--   </pre>
setGridLayoutColumnSpacing :: (MonadIO m, IsGridLayout o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-homogeneous</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGridLayoutRowHomogeneous :: (IsGridLayout o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayout #rowHomogeneous
--   </pre>
getGridLayoutRowHomogeneous :: (MonadIO m, IsGridLayout o) => o -> m Bool

-- | Set the value of the “<tt>row-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayout [ #rowHomogeneous <a>:=</a> value ]
--   </pre>
setGridLayoutRowHomogeneous :: (MonadIO m, IsGridLayout o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridLayoutRowSpacing :: (IsGridLayout o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gridLayout #rowSpacing
--   </pre>
getGridLayoutRowSpacing :: (MonadIO m, IsGridLayout o) => o -> m Int32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gridLayout [ #rowSpacing <a>:=</a> value ]
--   </pre>
setGridLayoutRowSpacing :: (MonadIO m, IsGridLayout o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.GridLayout.GridLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GridLayout.GridLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GridLayout.GridLayout
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GridLayout.GridLayout)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GridLayout.GridLayout o) => GI.Gtk.Objects.GridLayout.IsGridLayout o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GridLayout.GridLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GridLayout.GridLayout


-- | Arranges its child widgets in rows and columns.
--   
--   &lt;picture&gt; &lt;source srcset="grid-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkGrid" src="grid.png"&gt; &lt;/picture&gt;
--   
--   It supports arbitrary positions and horizontal/vertical spans.
--   
--   Children are added using <a>gridAttach</a>. They can span multiple
--   rows or columns. It is also possible to add a child next to an
--   existing child, using <a>gridAttachNextTo</a>. To remove a child from
--   the grid, use <a>gridRemove</a>.
--   
--   The behaviour of <tt>GtkGrid</tt> when several children occupy the
--   same grid cell is undefined.
--   
--   <h1>GtkGrid as GtkBuildable</h1>
--   
--   Every child in a <tt>GtkGrid</tt> has access to a custom
--   <a>Buildable</a> element, called <tt>&lt;layout&gt;</tt>. It can by
--   used to specify a position in the grid and optionally spans. All
--   properties that can be used in the <tt>&lt;layout&gt;</tt> element are
--   implemented by <a>GridLayoutChild</a>.
--   
--   It is implemented by <tt>GtkWidget</tt> using <a>LayoutManager</a>.
--   
--   To showcase it, here is a simple example:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkGrid" id="my_grid"&gt;
--     &lt;child&gt;
--       &lt;object class="GtkButton" id="button1"&gt;
--         &lt;property name="label"&gt;Button 1&lt;/property&gt;
--         &lt;layout&gt;
--           &lt;property name="column"&gt;0&lt;/property&gt;
--           &lt;property name="row"&gt;0&lt;/property&gt;
--         &lt;/layout&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;child&gt;
--       &lt;object class="GtkButton" id="button2"&gt;
--         &lt;property name="label"&gt;Button 2&lt;/property&gt;
--         &lt;layout&gt;
--           &lt;property name="column"&gt;1&lt;/property&gt;
--           &lt;property name="row"&gt;0&lt;/property&gt;
--         &lt;/layout&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;child&gt;
--       &lt;object class="GtkButton" id="button3"&gt;
--         &lt;property name="label"&gt;Button 3&lt;/property&gt;
--         &lt;layout&gt;
--           &lt;property name="column"&gt;2&lt;/property&gt;
--           &lt;property name="row"&gt;0&lt;/property&gt;
--           &lt;property name="row-span"&gt;2&lt;/property&gt;
--         &lt;/layout&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;child&gt;
--       &lt;object class="GtkButton" id="button4"&gt;
--         &lt;property name="label"&gt;Button 4&lt;/property&gt;
--         &lt;layout&gt;
--           &lt;property name="column"&gt;0&lt;/property&gt;
--           &lt;property name="row"&gt;1&lt;/property&gt;
--           &lt;property name="column-span"&gt;2&lt;/property&gt;
--         &lt;/layout&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   It organizes the first two buttons side-by-side in one cell each. The
--   third button is in the last column but spans across two rows. This is
--   defined by the <tt>row-span</tt> property. The last button is located
--   in the second row and spans across two columns, which is defined by
--   the <tt>column-span</tt> property.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkGrid</tt> uses a single CSS node with name <tt>grid</tt>.
--   
--   <h1>Accessibility</h1>
--   
--   Until GTK 4.10, <tt>GtkGrid</tt> used the <a>AccessibleRoleGroup</a>
--   role.
--   
--   Starting from GTK 4.12, <tt>GtkGrid</tt> uses the
--   <a>AccessibleRoleGeneric</a> role.
module GI.Gtk.Objects.Grid

-- | Memory-managed wrapper type.
newtype Grid
Grid :: ManagedPtr Grid -> Grid

-- | Type class for types which can be safely cast to <a>Grid</a>, for
--   instance with <a>toGrid</a>.
class (GObject o, IsDescendantOf Grid o) => IsGrid o

-- | Cast to <a>Grid</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toGrid :: (MonadIO m, IsGrid o) => o -> m Grid

-- | Adds a widget to the grid.
--   
--   The position of <i><tt>child</tt></i> is determined by
--   <i><tt>column</tt></i> and <i><tt>row</tt></i>. The number of “cells”
--   that <i><tt>child</tt></i> will occupy is determined by
--   <i><tt>width</tt></i> and <i><tt>height</tt></i>.
gridAttach :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b) => a -> b -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Adds a widget to the grid.
--   
--   The widget is placed next to <i><tt>sibling</tt></i>, on the side
--   determined by <i><tt>side</tt></i>. When <i><tt>sibling</tt></i> is
--   <a>Nothing</a>, the widget is placed in row (for left or right
--   placement) or column 0 (for top or bottom placement), at the end
--   indicated by <i><tt>side</tt></i>.
--   
--   Attaching widgets labeled <tt>[1]</tt>, <tt>[2]</tt>, <tt>[3]</tt>
--   with <tt>@sibling == %NULL</tt> and <tt>@side == %GTK_POS_LEFT</tt>
--   yields a layout of <tt>[3][2][1]</tt>.
gridAttachNextTo :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> PositionType -> Int32 -> Int32 -> m ()

-- | Returns which row defines the global baseline of <i><tt>grid</tt></i>.
gridGetBaselineRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Int32

-- | Gets the child of <i><tt>grid</tt></i> whose area covers the grid cell
--   at <i><tt>column</tt></i>, <i><tt>row</tt></i>.
gridGetChildAt :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> Int32 -> m (Maybe Widget)

-- | Returns whether all columns of <i><tt>grid</tt></i> have the same
--   width.
gridGetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Bool

-- | Returns the amount of space between the columns of
--   <i><tt>grid</tt></i>.
gridGetColumnSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Word32

-- | Returns the baseline position of <i><tt>row</tt></i>.
--   
--   See <a>gridSetRowBaselinePosition</a>.
gridGetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m BaselinePosition

-- | Returns whether all rows of <i><tt>grid</tt></i> have the same height.
gridGetRowHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Bool

-- | Returns the amount of space between the rows of <i><tt>grid</tt></i>.
gridGetRowSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> m Word32

-- | Inserts a column at the specified position.
--   
--   Children which are attached at or to the right of this position are
--   moved one column to the right. Children which span across this
--   position are grown to span the new column.
gridInsertColumn :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Inserts a row or column at the specified position.
--   
--   The new row or column is placed next to <i><tt>sibling</tt></i>, on
--   the side determined by <i><tt>side</tt></i>. If <i><tt>side</tt></i>
--   is <a>PositionTypeTop</a> or <a>PositionTypeBottom</a>, a row is
--   inserted. If <i><tt>side</tt></i> is <a>PositionTypeLeft</a> of
--   <a>PositionTypeRight</a>, a column is inserted.
gridInsertNextTo :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b) => a -> b -> PositionType -> m ()

-- | Inserts a row at the specified position.
--   
--   Children which are attached at or below this position are moved one
--   row down. Children which span across this position are grown to span
--   the new row.
gridInsertRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Creates a new grid widget.
gridNew :: (HasCallStack, MonadIO m) => m Grid

-- | Queries the attach points and spans of <i><tt>child</tt></i> inside
--   the given <tt>GtkGrid</tt>.
gridQueryChild :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b) => a -> b -> m (Int32, Int32, Int32, Int32)

-- | Removes a child from <i><tt>grid</tt></i>.
--   
--   The child must have been added with <a>gridAttach</a> or
--   <a>gridAttachNextTo</a>.
gridRemove :: (HasCallStack, MonadIO m, IsGrid a, IsWidget b) => a -> b -> m ()

-- | Removes a column from the grid.
--   
--   Children that are placed in this column are removed, spanning children
--   that overlap this column have their width reduced by one, and children
--   after the column are moved to the left.
gridRemoveColumn :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Removes a row from the grid.
--   
--   Children that are placed in this row are removed, spanning children
--   that overlap this row have their height reduced by one, and children
--   below the row are moved up.
gridRemoveRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Sets which row defines the global baseline for the entire grid.
--   
--   Each row in the grid can have its own local baseline, but only one of
--   those is global, meaning it will be the baseline in the parent of the
--   <i><tt>grid</tt></i>.
gridSetBaselineRow :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> m ()

-- | Sets whether all columns of <i><tt>grid</tt></i> will have the same
--   width.
gridSetColumnHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> Bool -> m ()

-- | Sets the amount of space between columns of <i><tt>grid</tt></i>.
gridSetColumnSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> Word32 -> m ()

-- | Sets how the baseline should be positioned on <i><tt>row</tt></i> of
--   the grid, in case that row is assigned more space than is requested.
--   
--   The default baseline position is <a>BaselinePositionCenter</a>.
gridSetRowBaselinePosition :: (HasCallStack, MonadIO m, IsGrid a) => a -> Int32 -> BaselinePosition -> m ()

-- | Sets whether all rows of <i><tt>grid</tt></i> will have the same
--   height.
gridSetRowHomogeneous :: (HasCallStack, MonadIO m, IsGrid a) => a -> Bool -> m ()

-- | Sets the amount of space between rows of <i><tt>grid</tt></i>.
gridSetRowSpacing :: (HasCallStack, MonadIO m, IsGrid a) => a -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-row</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridBaselineRow :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #baselineRow
--   </pre>
getGridBaselineRow :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “<tt>baseline-row</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #baselineRow <a>:=</a> value ]
--   </pre>
setGridBaselineRow :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-homogeneous</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructGridColumnHomogeneous :: (IsGrid o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #columnHomogeneous
--   </pre>
getGridColumnHomogeneous :: (MonadIO m, IsGrid o) => o -> m Bool

-- | Set the value of the “<tt>column-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #columnHomogeneous <a>:=</a> value ]
--   </pre>
setGridColumnHomogeneous :: (MonadIO m, IsGrid o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGridColumnSpacing :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #columnSpacing
--   </pre>
getGridColumnSpacing :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #columnSpacing <a>:=</a> value ]
--   </pre>
setGridColumnSpacing :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-homogeneous</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGridRowHomogeneous :: (IsGrid o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #rowHomogeneous
--   </pre>
getGridRowHomogeneous :: (MonadIO m, IsGrid o) => o -> m Bool

-- | Set the value of the “<tt>row-homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #rowHomogeneous <a>:=</a> value ]
--   </pre>
setGridRowHomogeneous :: (MonadIO m, IsGrid o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGridRowSpacing :: (IsGrid o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> grid #rowSpacing
--   </pre>
getGridRowSpacing :: (MonadIO m, IsGrid o) => o -> m Int32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> grid [ #rowSpacing <a>:=</a> value ]
--   </pre>
setGridRowSpacing :: (MonadIO m, IsGrid o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Grid.Grid
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Grid.Grid
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Grid.Grid
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Grid.Grid)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Grid.Grid o) => GI.Gtk.Objects.Grid.IsGrid o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Grid.Grid
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Grid.Grid


-- | Bypasses gsk rendering by passing the content of its child directly to
--   the compositor.
--   
--   Graphics offload is an optimization to reduce overhead and battery use
--   that is most useful for video content. It only works on some platforms
--   and in certain situations. GTK will automatically fall back to normal
--   rendering if it doesn't.
--   
--   Graphics offload is most efficient if there are no controls drawn on
--   top of the video content.
--   
--   You should consider using graphics offload for your main widget if it
--   shows frequently changing content (such as a video, or a VM display)
--   and you provide the content in the form of dmabuf textures (see
--   <a>DmabufTextureBuilder</a>), in particular if it may be fullscreen.
--   
--   Numerous factors can prohibit graphics offload:
--   
--   <ul>
--   <li>Unsupported platforms. Currently, graphics offload only works on
--   Linux with Wayland.</li>
--   <li>Clipping, such as rounded corners that cause the video content to
--   not be rectangular</li>
--   <li>Unsupported dmabuf formats (see
--   <a>displayGetDmabufFormats</a>)</li>
--   <li>Translucent video content (content with an alpha channel, even if
--   it isn't used)</li>
--   <li>Transforms that are more complex than translations and scales</li>
--   <li>Filters such as opacity, grayscale or similar</li>
--   </ul>
--   
--   To investigate problems related graphics offload, GTK offers debug
--   flags to print out information about graphics offload and dmabuf use:
--   
--   GDK_DEBUG=offload GDK_DEBUG=dmabuf
--   
--   The GTK inspector provides a visual debugging tool for graphics
--   offload.
--   
--   <i>Since: 4.14</i>
module GI.Gtk.Objects.GraphicsOffload

-- | Memory-managed wrapper type.
newtype GraphicsOffload
GraphicsOffload :: ManagedPtr GraphicsOffload -> GraphicsOffload

-- | Type class for types which can be safely cast to
--   <a>GraphicsOffload</a>, for instance with <a>toGraphicsOffload</a>.
class (GObject o, IsDescendantOf GraphicsOffload o) => IsGraphicsOffload o

-- | Cast to <a>GraphicsOffload</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toGraphicsOffload :: (MonadIO m, IsGraphicsOffload o) => o -> m GraphicsOffload

-- | Returns whether the widget draws a black background.
--   
--   See <a>graphicsOffloadSetBlackBackground</a>.
--   
--   <i>Since: 4.16</i>
graphicsOffloadGetBlackBackground :: (HasCallStack, MonadIO m, IsGraphicsOffload a) => a -> m Bool

-- | Gets the child of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.14</i>
graphicsOffloadGetChild :: (HasCallStack, MonadIO m, IsGraphicsOffload a) => a -> m (Maybe Widget)

-- | Returns whether offload is enabled for <i><tt>self</tt></i>.
--   
--   <i>Since: 4.14</i>
graphicsOffloadGetEnabled :: (HasCallStack, MonadIO m, IsGraphicsOffload a) => a -> m GraphicsOffloadEnabled

-- | Creates a new GtkGraphicsOffload widget.
--   
--   <i>Since: 4.14</i>
graphicsOffloadNew :: (HasCallStack, MonadIO m, IsWidget a) => Maybe a -> m GraphicsOffload

-- | Sets whether this GtkGraphicsOffload widget will draw a black
--   background.
--   
--   A main use case for this is <b>_letterboxing</b>_ where black bars are
--   visible next to the content if the aspect ratio of the content does
--   not match the dimensions of the monitor.
--   
--   Using this property for letterboxing instead of CSS allows compositors
--   to show content with maximum efficiency, using direct scanout to avoid
--   extra copies in the compositor.
--   
--   On Wayland, this is implemented using the <a>single-pixel buffer</a>
--   protocol.
--   
--   <i>Since: 4.16</i>
graphicsOffloadSetBlackBackground :: (HasCallStack, MonadIO m, IsGraphicsOffload a) => a -> Bool -> m ()

-- | Sets the child of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.14</i>
graphicsOffloadSetChild :: (HasCallStack, MonadIO m, IsGraphicsOffload a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether this GtkGraphicsOffload widget will attempt to offload
--   the content of its child widget.
--   
--   <i>Since: 4.14</i>
graphicsOffloadSetEnabled :: (HasCallStack, MonadIO m, IsGraphicsOffload a) => a -> GraphicsOffloadEnabled -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>black-background</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGraphicsOffloadBlackBackground :: (IsGraphicsOffload o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>black-background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> graphicsOffload #blackBackground
--   </pre>
getGraphicsOffloadBlackBackground :: (MonadIO m, IsGraphicsOffload o) => o -> m Bool

-- | Set the value of the “<tt>black-background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> graphicsOffload [ #blackBackground <a>:=</a> value ]
--   </pre>
setGraphicsOffloadBlackBackground :: (MonadIO m, IsGraphicsOffload o) => o -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearGraphicsOffloadChild :: (MonadIO m, IsGraphicsOffload o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGraphicsOffloadChild :: (IsGraphicsOffload o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> graphicsOffload #child
--   </pre>
getGraphicsOffloadChild :: (MonadIO m, IsGraphicsOffload o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> graphicsOffload [ #child <a>:=</a> value ]
--   </pre>
setGraphicsOffloadChild :: (MonadIO m, IsGraphicsOffload o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enabled</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGraphicsOffloadEnabled :: (IsGraphicsOffload o, MonadIO m) => GraphicsOffloadEnabled -> m (GValueConstruct o)

-- | Get the value of the “<tt>enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> graphicsOffload #enabled
--   </pre>
getGraphicsOffloadEnabled :: (MonadIO m, IsGraphicsOffload o) => o -> m GraphicsOffloadEnabled

-- | Set the value of the “<tt>enabled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> graphicsOffload [ #enabled <a>:=</a> value ]
--   </pre>
setGraphicsOffloadEnabled :: (MonadIO m, IsGraphicsOffload o) => o -> GraphicsOffloadEnabled -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.GraphicsOffload.GraphicsOffload
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GraphicsOffload.GraphicsOffload
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GraphicsOffload.GraphicsOffload
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GraphicsOffload.GraphicsOffload)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GraphicsOffload.GraphicsOffload o) => GI.Gtk.Objects.GraphicsOffload.IsGraphicsOffload o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GraphicsOffload.GraphicsOffload
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GraphicsOffload.GraphicsOffload


-- | Recognizes 2-finger pinch/zoom gestures.
--   
--   Whenever the distance between both tracked sequences changes, the
--   <a>GestureZoom::scaleChanged</a> signal is emitted to report the scale
--   factor.
module GI.Gtk.Objects.GestureZoom

-- | Memory-managed wrapper type.
newtype GestureZoom
GestureZoom :: ManagedPtr GestureZoom -> GestureZoom

-- | Type class for types which can be safely cast to <a>GestureZoom</a>,
--   for instance with <a>toGestureZoom</a>.
class (GObject o, IsDescendantOf GestureZoom o) => IsGestureZoom o

-- | Cast to <a>GestureZoom</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureZoom :: (MonadIO m, IsGestureZoom o) => o -> m GestureZoom

-- | Gets the scale delta.
--   
--   If <i><tt>gesture</tt></i> is active, this function returns the
--   zooming difference since the gesture was recognized (hence the
--   starting point is considered 1:1). If <i><tt>gesture</tt></i> is not
--   active, 1 is returned.
gestureZoomGetScaleDelta :: (HasCallStack, MonadIO m, IsGestureZoom a) => a -> m Double

-- | Returns a newly created <tt>GtkGesture</tt> that recognizes pinch/zoom
--   gestures.
gestureZoomNew :: (HasCallStack, MonadIO m) => m GestureZoom

-- | Emitted whenever the distance between both tracked sequences changes.
type GestureZoomScaleChangedCallback = Double -> IO ()

-- | Connect a signal handler for the <a>scaleChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureZoom #scaleChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureZoomScaleChanged :: (IsGestureZoom a, MonadIO m) => a -> ((?self :: a) => GestureZoomScaleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scaleChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureZoom #scaleChanged callback
--   </pre>
onGestureZoomScaleChanged :: (IsGestureZoom a, MonadIO m) => a -> ((?self :: a) => GestureZoomScaleChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GestureZoom.GestureZoom
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureZoom.GestureZoom
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureZoom.GestureZoom
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureZoom.GestureZoom)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureZoom.GestureZoom o) => GI.Gtk.Objects.GestureZoom.IsGestureZoom o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureZoom.GestureZoom
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureZoom.GestureZoom


-- | Recognizes swipe gestures.
--   
--   After a press/move/.../move/release sequence happens, the
--   <a>GestureSwipe::swipe</a> signal will be emitted, providing the
--   velocity and directionality of the sequence at the time it was lifted.
--   
--   If the velocity is desired in intermediate points,
--   <a>gestureSwipeGetVelocity</a> can be called in a
--   <a>Gesture::update</a> handler.
--   
--   All velocities are reported in pixels/sec units.
module GI.Gtk.Objects.GestureSwipe

-- | Memory-managed wrapper type.
newtype GestureSwipe
GestureSwipe :: ManagedPtr GestureSwipe -> GestureSwipe

-- | Type class for types which can be safely cast to <a>GestureSwipe</a>,
--   for instance with <a>toGestureSwipe</a>.
class (GObject o, IsDescendantOf GestureSwipe o) => IsGestureSwipe o

-- | Cast to <a>GestureSwipe</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureSwipe :: (MonadIO m, IsGestureSwipe o) => o -> m GestureSwipe

-- | Gets the current velocity.
--   
--   If the gesture is recognized, this function returns <a>True</a> and
--   fills in <i><tt>velocityX</tt></i> and <i><tt>velocityY</tt></i> with
--   the recorded velocity, as per the last events processed.
gestureSwipeGetVelocity :: (HasCallStack, MonadIO m, IsGestureSwipe a) => a -> m (Bool, Double, Double)

-- | Returns a newly created <tt>GtkGesture</tt> that recognizes swipes.
gestureSwipeNew :: (HasCallStack, MonadIO m) => m GestureSwipe

-- | Emitted when the recognized gesture is finished.
--   
--   Velocity and direction are a product of previously recorded events.
type GestureSwipeSwipeCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>swipe</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureSwipe #swipe callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureSwipeSwipe :: (IsGestureSwipe a, MonadIO m) => a -> ((?self :: a) => GestureSwipeSwipeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>swipe</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gestureSwipe #swipe callback
--   </pre>
onGestureSwipeSwipe :: (IsGestureSwipe a, MonadIO m) => a -> ((?self :: a) => GestureSwipeSwipeCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GestureSwipe.GestureSwipe
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureSwipe.GestureSwipe
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureSwipe.GestureSwipe
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureSwipe.GestureSwipe)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureSwipe.GestureSwipe o) => GI.Gtk.Objects.GestureSwipe.IsGestureSwipe o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureSwipe.GestureSwipe
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureSwipe.GestureSwipe


-- | Recognizes tablet stylus input.
--   
--   The provided signals just relay the basic information of the stylus
--   events.
module GI.Gtk.Objects.GestureStylus

-- | Memory-managed wrapper type.
newtype GestureStylus
GestureStylus :: ManagedPtr GestureStylus -> GestureStylus

-- | Type class for types which can be safely cast to <a>GestureStylus</a>,
--   for instance with <a>toGestureStylus</a>.
class (GObject o, IsDescendantOf GestureStylus o) => IsGestureStylus o

-- | Cast to <a>GestureStylus</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureStylus :: (MonadIO m, IsGestureStylus o) => o -> m GestureStylus

-- | Returns the current value for the requested <i><tt>axis</tt></i>.
--   
--   This function must be called from the handler of one of the
--   <a>GestureStylus::down</a>, <a>GestureStylus::motion</a>,
--   <a>GestureStylus::up</a> or <a>GestureStylus::proximity</a> signals.
gestureStylusGetAxis :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> AxisUse -> m (Bool, Double)

-- | Returns the accumulated backlog of tracking information.
--   
--   By default, GTK will limit rate of input events. On stylus input where
--   accuracy of strokes is paramount, this function returns the
--   accumulated coordinate/timing state before the emission of the current
--   <a>Gtk.GestureStylus[motion</a>] signal.
--   
--   This function may only be called within a <a>GestureStylus::motion</a>
--   signal handler, the state given in this signal and obtainable through
--   <a>gestureStylusGetAxis</a> express the latest (most up-to-date) state
--   in motion history.
--   
--   The <i><tt>backlog</tt></i> is provided in chronological order.
gestureStylusGetBacklog :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> m (Bool, [TimeCoord])

-- | Returns the <tt>GdkDeviceTool</tt> currently driving input through
--   this gesture.
--   
--   This function must be called from the handler of one of the
--   <a>GestureStylus::down</a>, <a>GestureStylus::motion</a>,
--   <a>GestureStylus::up</a> or <a>GestureStylus::proximity</a> signals.
gestureStylusGetDeviceTool :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> m (Maybe DeviceTool)

-- | Checks whether the gesture is for styluses only.
--   
--   Stylus-only gestures will signal events exclusively from stylus input
--   devices.
--   
--   <i>Since: 4.10</i>
gestureStylusGetStylusOnly :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> m Bool

-- | Creates a new <tt>GtkGestureStylus</tt>.
gestureStylusNew :: (HasCallStack, MonadIO m) => m GestureStylus

-- | Sets the state of stylus-only
--   
--   If true, the gesture will exclusively handle events from stylus input
--   devices, otherwise it'll handle events from any pointing device.
--   
--   <i>Since: 4.10</i>
gestureStylusSetStylusOnly :: (HasCallStack, MonadIO m, IsGestureStylus a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stylus-only</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGestureStylusStylusOnly :: (IsGestureStylus o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>stylus-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureStylus #stylusOnly
--   </pre>
getGestureStylusStylusOnly :: (MonadIO m, IsGestureStylus o) => o -> m Bool

-- | Set the value of the “<tt>stylus-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureStylus [ #stylusOnly <a>:=</a> value ]
--   </pre>
setGestureStylusStylusOnly :: (MonadIO m, IsGestureStylus o) => o -> Bool -> m ()

-- | Emitted when the stylus touches the device.
type GestureStylusDownCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>down</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #down callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusDownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>down</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #down callback
--   </pre>
onGestureStylusDown :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusDownCallback) -> m SignalHandlerId

-- | Emitted when the stylus moves while touching the device.
type GestureStylusMotionCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>motion</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #motion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #motion callback
--   </pre>
onGestureStylusMotion :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusMotionCallback) -> m SignalHandlerId

-- | Emitted when the stylus is in proximity of the device.
type GestureStylusProximityCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>proximity</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #proximity callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusProximityCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>proximity</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #proximity callback
--   </pre>
onGestureStylusProximity :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusProximityCallback) -> m SignalHandlerId

-- | Emitted when the stylus no longer touches the device.
type GestureStylusUpCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>up</a> signal, to be run after the
--   default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureStylus #up callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusUpCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>up</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gestureStylus #up callback
--   </pre>
onGestureStylusUp :: (IsGestureStylus a, MonadIO m) => a -> ((?self :: a) => GestureStylusUpCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GestureStylus.GestureStylus
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureStylus.GestureStylus
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureStylus.GestureStylus
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureStylus.GestureStylus)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureStylus.GestureStylus o) => GI.Gtk.Objects.GestureStylus.IsGestureStylus o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureStylus.GestureStylus
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureStylus.GestureStylus


-- | A <tt>GtkGesture</tt> subclass optimized for singe-touch and mouse
--   gestures.
--   
--   Under interaction, these gestures stick to the first interacting
--   sequence, which is accessible through
--   <a>gestureSingleGetCurrentSequence</a> while the gesture is being
--   interacted with.
--   
--   By default gestures react to both <a>BUTTON_PRIMARY</a> and touch
--   events. <a>gestureSingleSetTouchOnly</a> can be used to change the
--   touch behavior. Callers may also specify a different mouse button
--   number to interact with through <a>gestureSingleSetButton</a>, or
--   react to any mouse button by setting it to 0. While the gesture is
--   active, the button being currently pressed can be known through
--   <a>gestureSingleGetCurrentButton</a>.
module GI.Gtk.Objects.GestureSingle

-- | Memory-managed wrapper type.
newtype GestureSingle
GestureSingle :: ManagedPtr GestureSingle -> GestureSingle

-- | Type class for types which can be safely cast to <a>GestureSingle</a>,
--   for instance with <a>toGestureSingle</a>.
class (GObject o, IsDescendantOf GestureSingle o) => IsGestureSingle o

-- | Cast to <a>GestureSingle</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureSingle :: (MonadIO m, IsGestureSingle o) => o -> m GestureSingle

-- | Returns the button number <i><tt>gesture</tt></i> listens for.
--   
--   If this is 0, the gesture reacts to any button press.
gestureSingleGetButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Word32

-- | Returns the button number currently interacting with
--   <i><tt>gesture</tt></i>, or 0 if there is none.
gestureSingleGetCurrentButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Word32

-- | Returns the event sequence currently interacting with
--   <i><tt>gesture</tt></i>.
--   
--   This is only meaningful if <a>gestureIsActive</a> returns <a>True</a>.
gestureSingleGetCurrentSequence :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m (Maybe EventSequence)

-- | Gets whether a gesture is exclusive.
--   
--   For more information, see <a>gestureSingleSetExclusive</a>.
gestureSingleGetExclusive :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Bool

-- | Returns <a>True</a> if the gesture is only triggered by touch events.
gestureSingleGetTouchOnly :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> m Bool

-- | Sets the button number <i><tt>gesture</tt></i> listens to.
--   
--   If non-0, every button press from a different button number will be
--   ignored. Touch events implicitly match with button 1.
gestureSingleSetButton :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Word32 -> m ()

-- | Sets whether <i><tt>gesture</tt></i> is exclusive.
--   
--   An exclusive gesture will only handle pointer and "pointer emulated"
--   touch events, so at any given time, there is only one sequence able to
--   interact with those.
gestureSingleSetExclusive :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Bool -> m ()

-- | Sets whether to handle only touch events.
--   
--   If <i><tt>touchOnly</tt></i> is <a>True</a>, <i><tt>gesture</tt></i>
--   will only handle events of type <a>EventTypeTouchBegin</a>,
--   <a>EventTypeTouchUpdate</a> or <a>EventTypeTouchEnd</a>. If
--   <a>False</a>, mouse events will be handled too.
gestureSingleSetTouchOnly :: (HasCallStack, MonadIO m, IsGestureSingle a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>button</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGestureSingleButton :: (IsGestureSingle o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureSingle #button
--   </pre>
getGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> m Word32

-- | Set the value of the “<tt>button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureSingle [ #button <a>:=</a> value ]
--   </pre>
setGestureSingleButton :: (MonadIO m, IsGestureSingle o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>exclusive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGestureSingleExclusive :: (IsGestureSingle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>exclusive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureSingle #exclusive
--   </pre>
getGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> m Bool

-- | Set the value of the “<tt>exclusive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureSingle [ #exclusive <a>:=</a> value ]
--   </pre>
setGestureSingleExclusive :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>touch-only</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGestureSingleTouchOnly :: (IsGestureSingle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>touch-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureSingle #touchOnly
--   </pre>
getGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> m Bool

-- | Set the value of the “<tt>touch-only</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureSingle [ #touchOnly <a>:=</a> value ]
--   </pre>
setGestureSingleTouchOnly :: (MonadIO m, IsGestureSingle o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.GestureSingle.GestureSingle
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureSingle.GestureSingle
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureSingle.GestureSingle
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureSingle.GestureSingle)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureSingle.GestureSingle o) => GI.Gtk.Objects.GestureSingle.IsGestureSingle o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureSingle.GestureSingle
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureSingle.GestureSingle


-- | Recognizes 2-finger rotation gestures.
--   
--   Whenever the angle between both handled sequences changes, the
--   <a>GestureRotate::angleChanged</a> signal is emitted.
module GI.Gtk.Objects.GestureRotate

-- | Memory-managed wrapper type.
newtype GestureRotate
GestureRotate :: ManagedPtr GestureRotate -> GestureRotate

-- | Type class for types which can be safely cast to <a>GestureRotate</a>,
--   for instance with <a>toGestureRotate</a>.
class (GObject o, IsDescendantOf GestureRotate o) => IsGestureRotate o

-- | Cast to <a>GestureRotate</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureRotate :: (MonadIO m, IsGestureRotate o) => o -> m GestureRotate

-- | Gets the angle delta in radians.
--   
--   If <i><tt>gesture</tt></i> is active, this function returns the angle
--   difference in radians since the gesture was first recognized. If
--   <i><tt>gesture</tt></i> is not active, 0 is returned.
gestureRotateGetAngleDelta :: (HasCallStack, MonadIO m, IsGestureRotate a) => a -> m Double

-- | Returns a newly created <tt>GtkGesture</tt> that recognizes 2-touch
--   rotation gestures.
gestureRotateNew :: (HasCallStack, MonadIO m) => m GestureRotate

-- | Emitted when the angle between both tracked points changes.
type GestureRotateAngleChangedCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>angleChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureRotate #angleChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>angleChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureRotate #angleChanged callback
--   </pre>
onGestureRotateAngleChanged :: (IsGestureRotate a, MonadIO m) => a -> ((?self :: a) => GestureRotateAngleChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GestureRotate.GestureRotate
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureRotate.GestureRotate
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureRotate.GestureRotate
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureRotate.GestureRotate)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureRotate.GestureRotate o) => GI.Gtk.Objects.GestureRotate.IsGestureRotate o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureRotate.GestureRotate
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureRotate.GestureRotate


-- | Recognizes pan gestures.
--   
--   These are drags that are locked to happen along one axis. The axis
--   that a <tt>GtkGesturePan</tt> handles is defined at construct time,
--   and can be changed through <a>gesturePanSetOrientation</a>.
--   
--   When the gesture starts to be recognized, <tt>GtkGesturePan</tt> will
--   attempt to determine as early as possible whether the sequence is
--   moving in the expected direction, and denying the sequence if this
--   does not happen.
--   
--   Once a panning gesture along the expected axis is recognized, the
--   <a>GesturePan::pan</a> signal will be emitted as input events are
--   received, containing the offset in the given axis.
module GI.Gtk.Objects.GesturePan

-- | Memory-managed wrapper type.
newtype GesturePan
GesturePan :: ManagedPtr GesturePan -> GesturePan

-- | Type class for types which can be safely cast to <a>GesturePan</a>,
--   for instance with <a>toGesturePan</a>.
class (GObject o, IsDescendantOf GesturePan o) => IsGesturePan o

-- | Cast to <a>GesturePan</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGesturePan :: (MonadIO m, IsGesturePan o) => o -> m GesturePan

-- | Returns the orientation of the pan gestures that this
--   <i><tt>gesture</tt></i> expects.
gesturePanGetOrientation :: (HasCallStack, MonadIO m, IsGesturePan a) => a -> m Orientation

-- | Returns a newly created <tt>GtkGesture</tt> that recognizes pan
--   gestures.
gesturePanNew :: (HasCallStack, MonadIO m) => Orientation -> m GesturePan

-- | Sets the orientation to be expected on pan gestures.
gesturePanSetOrientation :: (HasCallStack, MonadIO m, IsGesturePan a) => a -> Orientation -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>orientation</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGesturePanOrientation :: (IsGesturePan o, MonadIO m) => Orientation -> m (GValueConstruct o)

-- | Get the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gesturePan #orientation
--   </pre>
getGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> m Orientation

-- | Set the value of the “<tt>orientation</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gesturePan [ #orientation <a>:=</a> value ]
--   </pre>
setGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> Orientation -> m ()

-- | Emitted once a panning gesture along the expected axis is detected.
type GesturePanPanCallback = PanDirection -> Double -> IO ()

-- | Connect a signal handler for the <a>pan</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesturePan #pan callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> ((?self :: a) => GesturePanPanCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pan</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gesturePan #pan callback
--   </pre>
onGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> ((?self :: a) => GesturePanPanCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GesturePan.GesturePan
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GesturePan.GesturePan
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GesturePan.GesturePan
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GesturePan.GesturePan)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GesturePan.GesturePan o) => GI.Gtk.Objects.GesturePan.IsGesturePan o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GesturePan.GesturePan
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GesturePan.GesturePan


-- | Recognizes long press gestures.
--   
--   This gesture is also known as “Press and Hold”.
--   
--   When the timeout is exceeded, the gesture is triggering the
--   <a>GestureLongPress::pressed</a> signal.
--   
--   If the touchpoint is lifted before the timeout passes, or if it drifts
--   too far of the initial press point, the
--   <a>GestureLongPress::cancelled</a> signal will be emitted.
--   
--   How long the timeout is before the <a>pressed</a> signal gets emitted
--   is determined by the <a>Settings:gtkLongPressTime</a> setting. It can
--   be modified by the <a>GestureLongPress:delayFactor</a> property.
module GI.Gtk.Objects.GestureLongPress

-- | Memory-managed wrapper type.
newtype GestureLongPress
GestureLongPress :: ManagedPtr GestureLongPress -> GestureLongPress

-- | Type class for types which can be safely cast to
--   <a>GestureLongPress</a>, for instance with <a>toGestureLongPress</a>.
class (GObject o, IsDescendantOf GestureLongPress o) => IsGestureLongPress o

-- | Cast to <a>GestureLongPress</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toGestureLongPress :: (MonadIO m, IsGestureLongPress o) => o -> m GestureLongPress

-- | Returns the delay factor.
gestureLongPressGetDelayFactor :: (HasCallStack, MonadIO m, IsGestureLongPress a) => a -> m Double

-- | Returns a newly created <tt>GtkGesture</tt> that recognizes long
--   presses.
gestureLongPressNew :: (HasCallStack, MonadIO m) => m GestureLongPress

-- | Applies the given delay factor.
--   
--   The default long press time will be multiplied by this value. Valid
--   values are in the range [0.5..2.0].
gestureLongPressSetDelayFactor :: (HasCallStack, MonadIO m, IsGestureLongPress a) => a -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>delay-factor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGestureLongPressDelayFactor :: (IsGestureLongPress o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>delay-factor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gestureLongPress #delayFactor
--   </pre>
getGestureLongPressDelayFactor :: (MonadIO m, IsGestureLongPress o) => o -> m Double

-- | Set the value of the “<tt>delay-factor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gestureLongPress [ #delayFactor <a>:=</a> value ]
--   </pre>
setGestureLongPressDelayFactor :: (MonadIO m, IsGestureLongPress o) => o -> Double -> m ()

-- | Emitted whenever a press moved too far, or was released before
--   <a>GestureLongPress::pressed</a> happened.
type GestureLongPressCancelledCallback = IO ()

-- | Connect a signal handler for the <a>cancelled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureLongPress #cancelled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureLongPressCancelled :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressCancelledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancelled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureLongPress #cancelled callback
--   </pre>
onGestureLongPressCancelled :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressCancelledCallback) -> m SignalHandlerId

-- | Emitted whenever a press goes unmoved/unreleased longer than what the
--   GTK defaults tell.
type GestureLongPressPressedCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureLongPress #pressed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureLongPressPressed :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureLongPress #pressed callback
--   </pre>
onGestureLongPressPressed :: (IsGestureLongPress a, MonadIO m) => a -> ((?self :: a) => GestureLongPressPressedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GestureLongPress.GestureLongPress
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureLongPress.GestureLongPress
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureLongPress.GestureLongPress
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureLongPress.GestureLongPress)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureLongPress.GestureLongPress o) => GI.Gtk.Objects.GestureLongPress.IsGestureLongPress o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureLongPress.GestureLongPress
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureLongPress.GestureLongPress


-- | Recognizes drag gestures.
--   
--   The drag operation itself can be tracked throughout the
--   <a>GestureDrag::dragBegin</a>, <a>GestureDrag::dragUpdate</a> and
--   <a>GestureDrag::dragEnd</a> signals, and the relevant coordinates can
--   be extracted through <a>gestureDragGetOffset</a> and
--   <a>gestureDragGetStartPoint</a>.
module GI.Gtk.Objects.GestureDrag

-- | Memory-managed wrapper type.
newtype GestureDrag
GestureDrag :: ManagedPtr GestureDrag -> GestureDrag

-- | Type class for types which can be safely cast to <a>GestureDrag</a>,
--   for instance with <a>toGestureDrag</a>.
class (GObject o, IsDescendantOf GestureDrag o) => IsGestureDrag o

-- | Cast to <a>GestureDrag</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureDrag :: (MonadIO m, IsGestureDrag o) => o -> m GestureDrag

-- | Gets the offset from the start point.
--   
--   If the <i><tt>gesture</tt></i> is active, this function returns
--   <a>True</a> and fills in <i><tt>x</tt></i> and <i><tt>y</tt></i> with
--   the coordinates of the current point, as an offset to the starting
--   drag point.
gestureDragGetOffset :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

-- | Gets the point where the drag started.
--   
--   If the <i><tt>gesture</tt></i> is active, this function returns
--   <a>True</a> and fills in <i><tt>x</tt></i> and <i><tt>y</tt></i> with
--   the drag start coordinates, in widget-relative coordinates.
gestureDragGetStartPoint :: (HasCallStack, MonadIO m, IsGestureDrag a) => a -> m (Bool, Double, Double)

-- | Returns a newly created <tt>GtkGesture</tt> that recognizes drags.
gestureDragNew :: (HasCallStack, MonadIO m) => m GestureDrag

-- | Emitted whenever dragging starts.
type GestureDragDragBeginCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureDrag #dragBegin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureDragDragBegin :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureDrag #dragBegin callback
--   </pre>
onGestureDragDragBegin :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragBeginCallback) -> m SignalHandlerId

-- | Emitted whenever the dragging is finished.
type GestureDragDragEndCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureDrag #dragEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureDragDragEnd :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureDrag #dragEnd callback
--   </pre>
onGestureDragDragEnd :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragEndCallback) -> m SignalHandlerId

-- | Emitted whenever the dragging point moves.
type GestureDragDragUpdateCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>dragUpdate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureDrag #dragUpdate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureDragDragUpdate :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragUpdate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureDrag #dragUpdate callback
--   </pre>
onGestureDragDragUpdate :: (IsGestureDrag a, MonadIO m) => a -> ((?self :: a) => GestureDragDragUpdateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GestureDrag.GestureDrag
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureDrag.GestureDrag
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureDrag.GestureDrag
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureDrag.GestureDrag)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureDrag.GestureDrag o) => GI.Gtk.Objects.GestureDrag.IsGestureDrag o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureDrag.GestureDrag
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureDrag.GestureDrag


-- | Recognizes click gestures.
--   
--   It is able to recognize multiple clicks on a nearby zone, which can be
--   listened for through the <a>GestureClick::pressed</a> signal. Whenever
--   time or distance between clicks exceed the GTK defaults,
--   <a>GestureClick::stopped</a> is emitted, and the click counter is
--   reset.
module GI.Gtk.Objects.GestureClick

-- | Memory-managed wrapper type.
newtype GestureClick
GestureClick :: ManagedPtr GestureClick -> GestureClick

-- | Type class for types which can be safely cast to <a>GestureClick</a>,
--   for instance with <a>toGestureClick</a>.
class (GObject o, IsDescendantOf GestureClick o) => IsGestureClick o

-- | Cast to <a>GestureClick</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGestureClick :: (MonadIO m, IsGestureClick o) => o -> m GestureClick

-- | Returns a newly created <tt>GtkGesture</tt> that recognizes single and
--   multiple presses.
gestureClickNew :: (HasCallStack, MonadIO m) => m GestureClick

-- | Emitted whenever a button or touch press happens.
type GestureClickPressedCallback = Int32 -> Double -> Double -> IO ()

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureClick #pressed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureClickPressed :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>pressed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureClick #pressed callback
--   </pre>
onGestureClickPressed :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickPressedCallback) -> m SignalHandlerId

-- | Emitted when a button or touch is released.
--   
--   <i><tt>nPress</tt></i> will report the number of press that is paired
--   to this event, note that <a>GestureClick::stopped</a> may have been
--   emitted between the press and its release, <i><tt>nPress</tt></i> will
--   only start over at the next press.
type GestureClickReleasedCallback = Int32 -> Double -> Double -> IO ()

-- | Connect a signal handler for the <a>released</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureClick #released callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureClickReleased :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>released</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureClick #released callback
--   </pre>
onGestureClickReleased :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickReleasedCallback) -> m SignalHandlerId

-- | Emitted whenever any time/distance threshold has been exceeded.
type GestureClickStoppedCallback = IO ()

-- | Connect a signal handler for the <a>stopped</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gestureClick #stopped callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureClickStopped :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickStoppedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>stopped</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gestureClick #stopped callback
--   </pre>
onGestureClickStopped :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickStoppedCallback) -> m SignalHandlerId

-- | Emitted whenever the gesture receives a release event that had no
--   previous corresponding press.
--   
--   Due to implicit grabs, this can only happen on situations where input
--   is grabbed elsewhere mid-press or the pressed widget voluntarily
--   relinquishes its implicit grab.
type GestureClickUnpairedReleaseCallback = Double -> Double -> Word32 -> Maybe EventSequence -> IO ()

-- | Connect a signal handler for the <a>unpairedRelease</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> gestureClick #unpairedRelease callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureClickUnpairedRelease :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickUnpairedReleaseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unpairedRelease</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> gestureClick #unpairedRelease callback
--   </pre>
onGestureClickUnpairedRelease :: (IsGestureClick a, MonadIO m) => a -> ((?self :: a) => GestureClickUnpairedReleaseCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GestureClick.GestureClick
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GestureClick.GestureClick
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GestureClick.GestureClick
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GestureClick.GestureClick)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GestureClick.GestureClick o) => GI.Gtk.Objects.GestureClick.IsGestureClick o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GestureClick.GestureClick
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GestureClick.GestureClick


-- | The base class for gesture recognition.
--   
--   Although <tt>GtkGesture</tt> is quite generalized to serve as a base
--   for multi-touch gestures, it is suitable to implement single-touch and
--   pointer-based gestures (using the special <a>Nothing</a>
--   <tt>GdkEventSequence</tt> value for these).
--   
--   The number of touches that a <tt>GtkGesture</tt> need to be recognized
--   is controlled by the <a>Gesture:nPoints</a> property, if a gesture is
--   keeping track of less or more than that number of sequences, it won't
--   check whether the gesture is recognized.
--   
--   As soon as the gesture has the expected number of touches, it will
--   check regularly if it is recognized, the criteria to consider a
--   gesture as "recognized" is left to <tt>GtkGesture</tt> subclasses.
--   
--   A recognized gesture will then emit the following signals:
--   
--   <ul>
--   <li><a>Gesture::begin</a> when the gesture is recognized.</li>
--   <li><a>Gesture::update</a>, whenever an input event is processed.</li>
--   <li><a>Gesture::end</a> when the gesture is no longer recognized.</li>
--   </ul>
--   
--   <h2>Event propagation</h2>
--   
--   In order to receive events, a gesture needs to set a propagation phase
--   through <a>eventControllerSetPropagationPhase</a>.
--   
--   In the capture phase, events are propagated from the toplevel down to
--   the target widget, and gestures that are attached to containers above
--   the widget get a chance to interact with the event before it reaches
--   the target.
--   
--   In the bubble phase, events are propagated up from the target widget
--   to the toplevel, and gestures that are attached to containers above
--   the widget get a chance to interact with events that have not been
--   handled yet.
--   
--   <h2>States of a sequence</h2>
--   
--   Whenever input interaction happens, a single event may trigger a
--   cascade of <tt>GtkGesture</tt>s, both across the parents of the widget
--   receiving the event and in parallel within an individual widget. It is
--   a responsibility of the widgets using those gestures to set the state
--   of touch sequences accordingly in order to enable cooperation of
--   gestures around the <tt>GdkEventSequence</tt>s triggering those.
--   
--   Within a widget, gestures can be grouped through <a>gestureGroup</a>.
--   Grouped gestures synchronize the state of sequences, so calling
--   <a>gestureSetState</a> on one will effectively propagate the state
--   throughout the group.
--   
--   By default, all sequences start out in the
--   <a>EventSequenceStateNone</a> state, sequences in this state trigger
--   the gesture event handler, but event propagation will continue
--   unstopped by gestures.
--   
--   If a sequence enters into the <a>EventSequenceStateDenied</a> state,
--   the gesture group will effectively ignore the sequence, letting events
--   go unstopped through the gesture, but the "slot" will still remain
--   occupied while the touch is active.
--   
--   If a sequence enters in the <a>EventSequenceStateClaimed</a> state,
--   the gesture group will grab all interaction on the sequence, by:
--   
--   <ul>
--   <li>Setting the same sequence to <a>EventSequenceStateDenied</a> on
--   every other gesture group within the widget, and every gesture on
--   parent widgets in the propagation chain.</li>
--   <li>Emitting <a>Gesture::cancel</a> on every gesture in widgets
--   underneath in the propagation chain.</li>
--   <li>Stopping event propagation after the gesture group handles the
--   event.</li>
--   </ul>
--   
--   Note: if a sequence is set early to <a>EventSequenceStateClaimed</a>
--   on <a>EventTypeTouchBegin</a>/<a>EventTypeButtonPress</a> (so those
--   events are captured before reaching the event widget, this implies
--   <a>PropagationPhaseCapture</a>), one similar event will be emulated if
--   the sequence changes to <a>EventSequenceStateDenied</a>. This way
--   event coherence is preserved before event propagation is unstopped
--   again.
--   
--   Sequence states can't be changed freely. See <a>gestureSetState</a> to
--   know about the possible lifetimes of a <tt>GdkEventSequence</tt>.
--   
--   <h2>Touchpad gestures</h2>
--   
--   On the platforms that support it, <tt>GtkGesture</tt> will handle
--   transparently touchpad gesture events. The only precautions users of
--   <tt>GtkGesture</tt> should do to enable this support are:
--   
--   <ul>
--   <li>If the gesture has <a>PropagationPhaseNone</a>, ensuring events of
--   type <a>EventTypeTouchpadSwipe</a> and <a>EventTypeTouchpadPinch</a>
--   are handled by the <tt>GtkGesture</tt></li>
--   </ul>
module GI.Gtk.Objects.Gesture

-- | Memory-managed wrapper type.
newtype Gesture
Gesture :: ManagedPtr Gesture -> Gesture

-- | Type class for types which can be safely cast to <a>Gesture</a>, for
--   instance with <a>toGesture</a>.
class (GObject o, IsDescendantOf Gesture o) => IsGesture o

-- | Cast to <a>Gesture</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toGesture :: (MonadIO m, IsGesture o) => o -> m Gesture

-- | If there are touch sequences being currently handled by
--   <i><tt>gesture</tt></i>, returns <a>True</a> and fills in
--   <i><tt>rect</tt></i> with the bounding box containing all active
--   touches.
--   
--   Otherwise, <a>False</a> will be returned.
--   
--   Note: This function will yield unexpected results on touchpad
--   gestures. Since there is no correlation between physical and pixel
--   distances, these will look as if constrained in an infinitely small
--   area, <i><tt>rect</tt></i> width and height will thus be 0 regardless
--   of the number of touchpoints.
gestureGetBoundingBox :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Rectangle)

-- | If there are touch sequences being currently handled by
--   <i><tt>gesture</tt></i>, returns <a>True</a> and fills in
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> with the center of the
--   bounding box containing all active touches.
--   
--   Otherwise, <a>False</a> will be returned.
gestureGetBoundingBoxCenter :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Bool, Double, Double)

-- | Returns the logical <tt>GdkDevice</tt> that is currently operating on
--   <i><tt>gesture</tt></i>.
--   
--   This returns <a>Nothing</a> if the gesture is not being interacted.
gestureGetDevice :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe Device)

-- | Returns all gestures in the group of <i><tt>gesture</tt></i>
gestureGetGroup :: (HasCallStack, MonadIO m, IsGesture a) => a -> m [Gesture]

-- | Returns the last event that was processed for
--   <i><tt>sequence</tt></i>.
--   
--   Note that the returned pointer is only valid as long as the
--   <i><tt>sequence</tt></i> is still interpreted by the
--   <i><tt>gesture</tt></i>. If in doubt, you should make a copy of the
--   event.
gestureGetLastEvent :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m (Maybe Event)

-- | Returns the <tt>GdkEventSequence</tt> that was last updated on
--   <i><tt>gesture</tt></i>.
gestureGetLastUpdatedSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> m (Maybe EventSequence)

-- | If <i><tt>sequence</tt></i> is currently being interpreted by
--   <i><tt>gesture</tt></i>, returns <a>True</a> and fills in
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> with the last coordinates
--   stored for that event sequence.
--   
--   The coordinates are always relative to the widget allocation.
gestureGetPoint :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m (Bool, Double, Double)

-- | Returns the <i><tt>sequence</tt></i> state, as seen by
--   <i><tt>gesture</tt></i>.
gestureGetSequenceState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequence -> m EventSequenceState

-- | Returns the list of <tt>GdkEventSequences</tt> currently being
--   interpreted by <i><tt>gesture</tt></i>.
gestureGetSequences :: (HasCallStack, MonadIO m, IsGesture a) => a -> m [EventSequence]

-- | Adds <i><tt>gesture</tt></i> to the same group than
--   <i><tt>groupGesture</tt></i>.
--   
--   Gestures are by default isolated in their own groups.
--   
--   Both gestures must have been added to the same widget before they can
--   be grouped.
--   
--   When gestures are grouped, the state of <tt>GdkEventSequences</tt> is
--   kept in sync for all of those, so calling
--   <a>gestureSetSequenceState</a>, on one will transfer the same value to
--   the others.
--   
--   Groups also perform an "implicit grabbing" of sequences, if a
--   <tt>GdkEventSequence</tt> state is set to
--   <a>EventSequenceStateClaimed</a> on one group, every other gesture
--   group attached to the same <tt>GtkWidget</tt> will switch the state
--   for that sequence to <a>EventSequenceStateDenied</a>.
gestureGroup :: (HasCallStack, MonadIO m, IsGesture a, IsGesture b) => a -> b -> m ()

-- | Returns <a>True</a> if <i><tt>gesture</tt></i> is currently handling
--   events corresponding to <i><tt>sequence</tt></i>.
gestureHandlesSequence :: (HasCallStack, MonadIO m, IsGesture a) => a -> Maybe EventSequence -> m Bool

-- | Returns <a>True</a> if the gesture is currently active.
--   
--   A gesture is active while there are touch sequences interacting with
--   it.
gestureIsActive :: (HasCallStack, MonadIO m, IsGesture a) => a -> m Bool

-- | Returns <a>True</a> if both gestures pertain to the same group.
gestureIsGroupedWith :: (HasCallStack, MonadIO m, IsGesture a, IsGesture b) => a -> b -> m Bool

-- | Returns <a>True</a> if the gesture is currently recognized.
--   
--   A gesture is recognized if there are as many interacting touch
--   sequences as required by <i><tt>gesture</tt></i>.
gestureIsRecognized :: (HasCallStack, MonadIO m, IsGesture a) => a -> m Bool

-- | Sets the state of <i><tt>sequence</tt></i> in <i><tt>gesture</tt></i>.
--   
--   Sequences start in state <a>EventSequenceStateNone</a>, and whenever
--   they change state, they can never go back to that state. Likewise,
--   sequences in state <a>EventSequenceStateDenied</a> cannot turn back to
--   a not denied state. With these rules, the lifetime of an event
--   sequence is constrained to the next four:
--   
--   <ul>
--   <li>None</li>
--   <li>None → Denied</li>
--   <li>None → Claimed</li>
--   <li>None → Claimed → Denied</li>
--   </ul>
--   
--   Note: Due to event handling ordering, it may be unsafe to set the
--   state on another gesture within a <a>Gesture::begin</a> signal
--   handler, as the callback might be executed before the other gesture
--   knows about the sequence. A safe way to perform this could be:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   first_gesture_begin_cb (GtkGesture       *first_gesture,
--                           GdkEventSequence *sequence,
--                           gpointer          user_data)
--   {
--     gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
--     gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
--   }
--   
--   static void
--   second_gesture_begin_cb (GtkGesture       *second_gesture,
--                            GdkEventSequence *sequence,
--                            gpointer          user_data)
--   {
--     if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
--       gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
--   }
--   </pre>
--   
--   If both gestures are in the same group, just set the state on the
--   gesture emitting the event, the sequence will be already be
--   initialized to the group's global state when the second gesture
--   processes the event.

-- | <i>Deprecated: (Since version 4.10.)Use <a>gestureSetState</a></i>
gestureSetSequenceState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequence -> EventSequenceState -> m Bool

-- | Sets the state of all sequences that <i><tt>gesture</tt></i> is
--   currently interacting with.
--   
--   Sequences start in state <a>EventSequenceStateNone</a>, and whenever
--   they change state, they can never go back to that state. Likewise,
--   sequences in state <a>EventSequenceStateDenied</a> cannot turn back to
--   a not denied state. With these rules, the lifetime of an event
--   sequence is constrained to the next four:
--   
--   <ul>
--   <li>None</li>
--   <li>None → Denied</li>
--   <li>None → Claimed</li>
--   <li>None → Claimed → Denied</li>
--   </ul>
--   
--   Note: Due to event handling ordering, it may be unsafe to set the
--   state on another gesture within a <a>Gesture::begin</a> signal
--   handler, as the callback might be executed before the other gesture
--   knows about the sequence. A safe way to perform this could be:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   first_gesture_begin_cb (GtkGesture       *first_gesture,
--                           GdkEventSequence *sequence,
--                           gpointer          user_data)
--   {
--     gtk_gesture_set_state (first_gesture, GTK_EVENT_SEQUENCE_CLAIMED);
--     gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
--   }
--   
--   static void
--   second_gesture_begin_cb (GtkGesture       *second_gesture,
--                            GdkEventSequence *sequence,
--                            gpointer          user_data)
--   {
--     if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
--       gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
--   }
--   </pre>
--   
--   If both gestures are in the same group, just set the state on the
--   gesture emitting the event, the sequence will be already be
--   initialized to the group's global state when the second gesture
--   processes the event.
gestureSetState :: (HasCallStack, MonadIO m, IsGesture a) => a -> EventSequenceState -> m Bool

-- | Separates <i><tt>gesture</tt></i> into an isolated group.
gestureUngroup :: (HasCallStack, MonadIO m, IsGesture a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-points</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGestureNPoints :: (IsGesture o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gesture #nPoints
--   </pre>
getGestureNPoints :: (MonadIO m, IsGesture o) => o -> m Word32

-- | Emitted when the gesture is recognized.
--   
--   This means the number of touch sequences matches
--   <a>Gesture:nPoints</a>.
--   
--   Note: These conditions may also happen when an extra touch (eg. a
--   third touch on a 2-touches gesture) is lifted, in that situation
--   <i><tt>sequence</tt></i> won't pertain to the current set of active
--   touches, so don't rely on this being true.
type GestureBeginCallback = Maybe EventSequence -> IO ()

-- | Connect a signal handler for the <a>begin</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #begin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureBegin :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>begin</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gesture #begin callback
--   </pre>
onGestureBegin :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureBeginCallback) -> m SignalHandlerId

-- | Emitted whenever a sequence is cancelled.
--   
--   This usually happens on active touches when
--   <a>eventControllerReset</a> is called on <i><tt>gesture</tt></i>
--   (manually, due to grabs...), or the individual
--   <i><tt>sequence</tt></i> was claimed by parent widgets' controllers
--   (see <a>gestureSetSequenceState</a>).
--   
--   <i><tt>gesture</tt></i> must forget everything about
--   <i><tt>sequence</tt></i> as in response to this signal.
type GestureCancelCallback = Maybe EventSequence -> IO ()

-- | Connect a signal handler for the <a>cancel</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #cancel callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureCancel :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gesture #cancel callback
--   </pre>
onGestureCancel :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureCancelCallback) -> m SignalHandlerId

-- | Emitted when <i><tt>gesture</tt></i> either stopped recognizing the
--   event sequences as something to be handled, or the number of touch
--   sequences became higher or lower than <a>Gesture:nPoints</a>.
--   
--   Note: <i><tt>sequence</tt></i> might not pertain to the group of
--   sequences that were previously triggering recognition on
--   <i><tt>gesture</tt></i> (ie. a just pressed touch sequence that
--   exceeds <a>Gesture:nPoints</a>). This situation may be detected by
--   checking through <a>gestureHandlesSequence</a>.
type GestureEndCallback = Maybe EventSequence -> IO ()

-- | Connect a signal handler for the <a>end</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #end callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureEnd :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>end</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> gesture #end callback
--   </pre>
onGestureEnd :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureEndCallback) -> m SignalHandlerId

-- | Emitted whenever a sequence state changes.
--   
--   See <a>gestureSetSequenceState</a> to know more about the expectable
--   sequence lifetimes.
type GestureSequenceStateChangedCallback = Maybe EventSequence -> EventSequenceState -> IO ()

-- | Connect a signal handler for the <a>sequenceStateChanged</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> gesture #sequenceStateChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureSequenceStateChanged :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureSequenceStateChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sequenceStateChanged</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> gesture #sequenceStateChanged callback
--   </pre>
onGestureSequenceStateChanged :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureSequenceStateChangedCallback) -> m SignalHandlerId

-- | Emitted whenever an event is handled while the gesture is recognized.
--   
--   <i><tt>sequence</tt></i> is guaranteed to pertain to the set of active
--   touches.
type GestureUpdateCallback = Maybe EventSequence -> IO ()

-- | Connect a signal handler for the <a>update</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gesture #update callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGestureUpdate :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>update</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gesture #update callback
--   </pre>
onGestureUpdate :: (IsGesture a, MonadIO m) => a -> ((?self :: a) => GestureUpdateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Gesture.Gesture
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Gesture.Gesture
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Gesture.Gesture
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Gesture.Gesture)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Gesture.Gesture o) => GI.Gtk.Objects.Gesture.IsGesture o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Gesture.Gesture
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Gesture.Gesture


-- | Allows drawing with OpenGL.
--   
--   &lt;picture&gt; &lt;source srcset="glarea-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkGLArea" src="glarea.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkGLArea</tt> sets up its own <a>GLContext</a>, and creates a
--   custom GL framebuffer that the widget will do GL rendering onto. It
--   also ensures that this framebuffer is the default GL rendering target
--   when rendering. The completed rendering is integrated into the larger
--   GTK scene graph as a texture.
--   
--   In order to draw, you have to connect to the <a>GLArea::render</a>
--   signal, or subclass <tt>GtkGLArea</tt> and override the
--   GtkGLAreaClass.render virtual function.
--   
--   The <tt>GtkGLArea</tt> widget ensures that the <tt>GdkGLContext</tt>
--   is associated with the widget's drawing area, and it is kept updated
--   when the size and position of the drawing area changes.
--   
--   <h2>Drawing with GtkGLArea</h2>
--   
--   The simplest way to draw using OpenGL commands in a <tt>GtkGLArea</tt>
--   is to create a widget instance and connect to the
--   <a>GLArea::render</a> signal:
--   
--   The <tt>render()</tt> function will be called when the
--   <tt>GtkGLArea</tt> is ready for you to draw its content:
--   
--   The initial contents of the framebuffer are transparent.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static gboolean
--   render (GtkGLArea *area, GdkGLContext *context)
--   {
--     // inside this function it's safe to use GL; the given
--     // GdkGLContext has been made current to the drawable
--     // surface used by the `GtkGLArea` and the viewport has
--     // already been set to be the size of the allocation
--   
--     // we can start by clearing the buffer
--     glClearColor (0, 0, 0, 0);
--     glClear (GL_COLOR_BUFFER_BIT);
--   
--     // record the active framebuffer ID, so we can return to it
--     // with `glBindFramebuffer (GL_FRAMEBUFFER, screen_fb)` should
--     // we, for instance, intend on utilizing the results of an
--     // intermediate render texture pass
--     GLuint screen_fb = 0;
--     glGetIntegerv (GL_FRAMEBUFFER_BINDING, &amp;screen_fb);
--   
--     // draw your object
--     // draw_an_object ();
--   
--     // we completed our drawing; the draw commands will be
--     // flushed at the end of the signal emission chain, and
--     // the buffers will be drawn on the window
--     return TRUE;
--   }
--   
--   void setup_glarea (void)
--   {
--     // create a GtkGLArea instance
--     GtkWidget *gl_area = gtk_gl_area_new ();
--   
--     // connect to the "render" signal
--     g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
--   }
--   </pre>
--   
--   If you need to initialize OpenGL state, e.g. buffer objects or
--   shaders, you should use the <a>Widget::realize</a> signal; you can use
--   the <a>Widget::unrealize</a> signal to clean up. Since the
--   <tt>GdkGLContext</tt> creation and initialization may fail, you will
--   need to check for errors, using <a>gLAreaGetError</a>.
--   
--   An example of how to safely initialize the GL state is:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   on_realize (GtkGLArea *area)
--   {
--     // We need to make the context current if we want to
--     // call GL API
--     gtk_gl_area_make_current (area);
--   
--     // If there were errors during the initialization or
--     // when trying to make the context current, this
--     // function will return a GError for you to catch
--     if (gtk_gl_area_get_error (area) != NULL)
--       return;
--   
--     // You can also use gtk_gl_area_set_error() in order
--     // to show eventual initialization errors on the
--     // GtkGLArea widget itself
--     GError *internal_error = NULL;
--     init_buffer_objects (&amp;error);
--     if (error != NULL)
--       {
--         gtk_gl_area_set_error (area, error);
--         g_error_free (error);
--         return;
--       }
--   
--     init_shaders (&amp;error);
--     if (error != NULL)
--       {
--         gtk_gl_area_set_error (area, error);
--         g_error_free (error);
--         return;
--       }
--   }
--   </pre>
--   
--   If you need to change the options for creating the
--   <tt>GdkGLContext</tt> you should use the <a>GLArea::createContext</a>
--   signal.
module GI.Gtk.Objects.GLArea

-- | Memory-managed wrapper type.
newtype GLArea
GLArea :: ManagedPtr GLArea -> GLArea

-- | Type class for types which can be safely cast to <a>GLArea</a>, for
--   instance with <a>toGLArea</a>.
class (GObject o, IsDescendantOf GLArea o) => IsGLArea o

-- | Cast to <a>GLArea</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toGLArea :: (MonadIO m, IsGLArea o) => o -> m GLArea

-- | Binds buffers to the framebuffer.
--   
--   Ensures that the <i><tt>area</tt></i> framebuffer object is made the
--   current draw and read target, and that all the required buffers for
--   the <i><tt>area</tt></i> are created and bound to the framebuffer.
--   
--   This function is automatically called before emitting the
--   <a>GLArea::render</a> signal, and doesn't normally need to be called
--   by application code.
gLAreaAttachBuffers :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | Gets the allowed APIs.
--   
--   See <a>gLAreaSetAllowedApis</a>.
--   
--   <i>Since: 4.12</i>
gLAreaGetAllowedApis :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m [GLAPI]

-- | Gets the API that is currently in use.
--   
--   If the GL area has not been realized yet, 0 is returned.
--   
--   <i>Since: 4.12</i>
gLAreaGetApi :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m [GLAPI]

-- | Returns whether the area is in auto render mode or not.
gLAreaGetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Retrieves the <tt>GdkGLContext</tt> used by <i><tt>area</tt></i>.
gLAreaGetContext :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Maybe GLContext)

-- | Gets the current error set on the <i><tt>area</tt></i>.
gLAreaGetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Maybe GError)

-- | Returns whether the area has a depth buffer.
gLAreaGetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Returns whether the area has a stencil buffer.
gLAreaGetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Retrieves the required version of OpenGL.
--   
--   See <a>gLAreaSetRequiredVersion</a>.
gLAreaGetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Int32, Int32)

-- | Returns whether the <tt>GtkGLArea</tt> should use OpenGL ES.
--   
--   See <a>gLAreaSetUseEs</a>.

-- | <i>Deprecated: (Since version 4.12)Use <a>gLAreaGetApi</a></i>
gLAreaGetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool

-- | Ensures that the <tt>GdkGLContext</tt> used by <i><tt>area</tt></i> is
--   associated with the <tt>GtkGLArea</tt>.
--   
--   This function is automatically called before emitting the
--   <a>GLArea::render</a> signal, and doesn't normally need to be called
--   by application code.
gLAreaMakeCurrent :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | Creates a new <tt>GtkGLArea</tt> widget.
gLAreaNew :: (HasCallStack, MonadIO m) => m GLArea

-- | Marks the currently rendered data (if any) as invalid, and queues a
--   redraw of the widget.
--   
--   This ensures that the <a>GLArea::render</a> signal is emitted during
--   the draw.
--   
--   This is only needed when <a>gLAreaSetAutoRender</a> has been called
--   with a <a>False</a> value. The default behaviour is to emit
--   <a>GLArea::render</a> on each draw.
gLAreaQueueRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()

-- | Sets the allowed APIs to create a context with.
--   
--   You should check <a>GLArea:api</a> before drawing with either API.
--   
--   By default, all APIs are allowed.
--   
--   <i>Since: 4.12</i>
gLAreaSetAllowedApis :: (HasCallStack, MonadIO m, IsGLArea a) => a -> [GLAPI] -> m ()

-- | Sets whether the <tt>GtkGLArea</tt> is in auto render mode.
--   
--   If <i><tt>autoRender</tt></i> is <a>True</a> the <a>GLArea::render</a>
--   signal will be emitted every time the widget draws. This is the
--   default and is useful if drawing the widget is faster.
--   
--   If <i><tt>autoRender</tt></i> is <a>False</a> the data from previous
--   rendering is kept around and will be used for drawing the widget the
--   next time, unless the window is resized. In order to force a rendering
--   <a>gLAreaQueueRender</a> must be called. This mode is useful when the
--   scene changes seldom, but takes a long time to redraw.
gLAreaSetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Sets an error on the area which will be shown instead of the GL
--   rendering.
--   
--   This is useful in the <a>GLArea::createContext</a> signal if GL
--   context creation fails.
gLAreaSetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Maybe GError -> m ()

-- | Sets whether the <tt>GtkGLArea</tt> should use a depth buffer.
--   
--   If <i><tt>hasDepthBuffer</tt></i> is <a>True</a> the widget will
--   allocate and enable a depth buffer for the target framebuffer.
--   Otherwise there will be none.
gLAreaSetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Sets whether the <tt>GtkGLArea</tt> should use a stencil buffer.
--   
--   If <i><tt>hasStencilBuffer</tt></i> is <a>True</a> the widget will
--   allocate and enable a stencil buffer for the target framebuffer.
--   Otherwise there will be none.
gLAreaSetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Sets the required version of OpenGL to be used when creating the
--   context for the widget.
--   
--   This function must be called before the area has been realized.
gLAreaSetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Int32 -> Int32 -> m ()

-- | Sets whether the <i><tt>area</tt></i> should create an OpenGL or an
--   OpenGL ES context.
--   
--   You should check the capabilities of the <tt>GdkGLContext</tt> before
--   drawing with either API.

-- | <i>Deprecated: (Since version 4.12)Use <a>gLAreaSetAllowedApis</a></i>
gLAreaSetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>allowed-apis</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGLAreaAllowedApis :: (IsGLArea o, MonadIO m) => [GLAPI] -> m (GValueConstruct o)

-- | Get the value of the “<tt>allowed-apis</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #allowedApis
--   </pre>
getGLAreaAllowedApis :: (MonadIO m, IsGLArea o) => o -> m [GLAPI]

-- | Set the value of the “<tt>allowed-apis</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #allowedApis <a>:=</a> value ]
--   </pre>
setGLAreaAllowedApis :: (MonadIO m, IsGLArea o) => o -> [GLAPI] -> m ()

-- | Get the value of the “<tt>api</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #api
--   </pre>
getGLAreaApi :: (MonadIO m, IsGLArea o) => o -> m [GLAPI]

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>auto-render</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructGLAreaAutoRender :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>auto-render</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #autoRender
--   </pre>
getGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>auto-render</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #autoRender <a>:=</a> value ]
--   </pre>
setGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Get the value of the “<tt>context</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #context
--   </pre>
getGLAreaContext :: (MonadIO m, IsGLArea o) => o -> m (Maybe GLContext)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-depth-buffer</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructGLAreaHasDepthBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-depth-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #hasDepthBuffer
--   </pre>
getGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>has-depth-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #hasDepthBuffer <a>:=</a> value ]
--   </pre>
setGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-stencil-buffer</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructGLAreaHasStencilBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-stencil-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #hasStencilBuffer
--   </pre>
getGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>has-stencil-buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #hasStencilBuffer <a>:=</a> value ]
--   </pre>
setGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-es</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGLAreaUseEs :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-es</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLArea #useEs
--   </pre>
getGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> m Bool

-- | Set the value of the “<tt>use-es</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> gLArea [ #useEs <a>:=</a> value ]
--   </pre>
setGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()

-- | Emitted when the widget is being realized.
--   
--   This allows you to override how the GL context is created. This is
--   useful when you want to reuse an existing GL context, or if you want
--   to try creating different kinds of GL options.
--   
--   If context creation fails then the signal handler can use
--   <a>gLAreaSetError</a> to register a more detailed error of how the
--   construction failed.
type GLAreaCreateContextCallback = IO GLContext

-- | Connect a signal handler for the <a>createContext</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> gLArea #createContext callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>createContext</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> gLArea #createContext callback
--   </pre>
onGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId

-- | Emitted every time the contents of the <tt>GtkGLArea</tt> should be
--   redrawn.
--   
--   The <i><tt>context</tt></i> is bound to the <i><tt>area</tt></i> prior
--   to emitting this function, and the buffers are painted to the window
--   once the emission terminates.
type GLAreaRenderCallback = GLContext -> IO Bool

-- | Connect a signal handler for the <a>render</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gLArea #render callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>render</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gLArea #render callback
--   </pre>
onGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId

-- | Emitted once when the widget is realized, and then each time the
--   widget is changed while realized.
--   
--   This is useful in order to keep GL state up to date with the widget
--   size, like for instance camera properties which may depend on the
--   width/height ratio.
--   
--   The GL context for the area is guaranteed to be current when this
--   signal is emitted.
--   
--   The default handler sets up the GL viewport.
type GLAreaResizeCallback = Int32 -> Int32 -> IO ()

-- | Connect a signal handler for the <a>resize</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> gLArea #resize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>resize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> gLArea #resize callback
--   </pre>
onGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.GLArea.GLArea
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.GLArea.GLArea
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.GLArea.GLArea
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.GLArea.GLArea o) => GI.Gtk.Objects.GLArea.IsGLArea o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.GLArea.GLArea)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.GLArea.GLArea
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.GLArea.GLArea


-- | Surrounds its child with a decorative frame and an optional label.
--   
--   &lt;picture&gt; &lt;source srcset="frame-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkFrame" src="frame.png"&gt; &lt;/picture&gt;
--   
--   If present, the label is drawn inside the top edge of the frame. The
--   horizontal position of the label can be controlled with
--   <a>frameSetLabelAlign</a>.
--   
--   <tt>GtkFrame</tt> clips its child. You can use this to add rounded
--   corners to widgets, but be aware that it also cuts off shadows.
--   
--   <h1>GtkFrame as GtkBuildable</h1>
--   
--   An example of a UI definition fragment with GtkFrame:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkFrame"&gt;
--     &lt;property name="label-widget"&gt;
--       &lt;object class="GtkLabel" id="frame_label"/&gt;
--     &lt;/property&gt;
--     &lt;property name="child"&gt;
--       &lt;object class="GtkEntry" id="frame_content"/&gt;
--     &lt;/property&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   frame
--   ├── &lt;label widget&gt;
--   ╰── &lt;child&gt;
--   </pre>
--   
--   <tt>GtkFrame</tt> has a main CSS node with name “frame”, which is used
--   to draw the visible border. You can set the appearance of the border
--   using CSS properties like “border-style” on this node.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkFrame</tt> uses the <a>AccessibleRoleGroup</a> role.
module GI.Gtk.Objects.Frame

-- | Memory-managed wrapper type.
newtype Frame
Frame :: ManagedPtr Frame -> Frame

-- | Type class for types which can be safely cast to <a>Frame</a>, for
--   instance with <a>toFrame</a>.
class (GObject o, IsDescendantOf Frame o) => IsFrame o

-- | Cast to <a>Frame</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFrame :: (MonadIO m, IsFrame o) => o -> m Frame

-- | Gets the child widget of <i><tt>frame</tt></i>.
frameGetChild :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Maybe Widget)

-- | Returns the frame labels text.
--   
--   If the frame's label widget is not a <tt>GtkLabel</tt>, <a>Nothing</a>
--   is returned.
frameGetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Maybe Text)

-- | Retrieves the X alignment of the frame’s label.
frameGetLabelAlign :: (HasCallStack, MonadIO m, IsFrame a) => a -> m Float

-- | Retrieves the label widget for the frame.
frameGetLabelWidget :: (HasCallStack, MonadIO m, IsFrame a) => a -> m (Maybe Widget)

-- | Creates a new <tt>GtkFrame</tt>, with optional label
--   <i><tt>label</tt></i>.
--   
--   If <i><tt>label</tt></i> is <a>Nothing</a>, the label is omitted.
frameNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Frame

-- | Sets the child widget of <i><tt>frame</tt></i>.
frameSetChild :: (HasCallStack, MonadIO m, IsFrame a, IsWidget b) => a -> Maybe b -> m ()

-- | Creates a new <tt>GtkLabel</tt> with the <i><tt>label</tt></i> and
--   sets it as the frame's label widget.
frameSetLabel :: (HasCallStack, MonadIO m, IsFrame a) => a -> Maybe Text -> m ()

-- | Sets the X alignment of the frame widget’s label.
--   
--   The default value for a newly created frame is 0.0.
frameSetLabelAlign :: (HasCallStack, MonadIO m, IsFrame a) => a -> Float -> m ()

-- | Sets the label widget for the frame.
--   
--   This is the widget that will appear embedded in the top edge of the
--   frame as a title.
frameSetLabelWidget :: (HasCallStack, MonadIO m, IsFrame a, IsWidget b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearFrameChild :: (MonadIO m, IsFrame o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFrameChild :: (IsFrame o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #child
--   </pre>
getFrameChild :: (MonadIO m, IsFrame o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #child <a>:=</a> value ]
--   </pre>
setFrameChild :: (MonadIO m, IsFrame o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>label</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearFrameLabel :: (MonadIO m, IsFrame o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFrameLabel :: (IsFrame o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #label
--   </pre>
getFrameLabel :: (MonadIO m, IsFrame o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #label <a>:=</a> value ]
--   </pre>
setFrameLabel :: (MonadIO m, IsFrame o) => o -> Text -> m ()

-- | Set the value of the “<tt>label-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #labelWidget
--   </pre>
clearFrameLabelWidget :: (MonadIO m, IsFrame o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFrameLabelWidget :: (IsFrame o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #labelWidget
--   </pre>
getFrameLabelWidget :: (MonadIO m, IsFrame o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #labelWidget <a>:=</a> value ]
--   </pre>
setFrameLabelWidget :: (MonadIO m, IsFrame o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-xalign</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFrameLabelXalign :: (IsFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>label-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> frame #labelXalign
--   </pre>
getFrameLabelXalign :: (MonadIO m, IsFrame o) => o -> m Float

-- | Set the value of the “<tt>label-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> frame [ #labelXalign <a>:=</a> value ]
--   </pre>
setFrameLabelXalign :: (MonadIO m, IsFrame o) => o -> Float -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Frame.Frame
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Frame.Frame
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Frame.Frame
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Frame.Frame o) => GI.Gtk.Objects.Frame.IsFrame o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Frame.Frame)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Frame.Frame
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Frame.Frame


-- | Opens a font chooser dialog to select a font.
--   
--   &lt;picture&gt; &lt;source srcset="font-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkFontDialogButton" src="font-button.png"&gt; &lt;/picture&gt;
--   
--   It is suitable widget for selecting a font in a preference dialog.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   fontbutton
--   ╰── button.font
--       ╰── [content]
--   </pre>
--   
--   <tt>GtkFontDialogButton</tt> has a single CSS node with name
--   fontbutton which contains a button node with the .font style class.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.FontDialogButton

-- | Memory-managed wrapper type.
newtype FontDialogButton
FontDialogButton :: ManagedPtr FontDialogButton -> FontDialogButton

-- | Type class for types which can be safely cast to
--   <a>FontDialogButton</a>, for instance with <a>toFontDialogButton</a>.
class (GObject o, IsDescendantOf FontDialogButton o) => IsFontDialogButton o

-- | Cast to <a>FontDialogButton</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFontDialogButton :: (MonadIO m, IsFontDialogButton o) => o -> m FontDialogButton

-- | Returns the <tt>GtkFontDialog</tt> of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.10</i>
fontDialogButtonGetDialog :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> m (Maybe FontDialog)

-- | Returns the font of the button.
--   
--   This function is what should be used to obtain the font that was
--   chosen by the user. To get informed about changes, listen to
--   "notify<a>fontDesc</a>".
--   
--   <i>Since: 4.10</i>
fontDialogButtonGetFontDesc :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> m (Maybe FontDescription)

-- | Returns the font features of the button.
--   
--   This function is what should be used to obtain the font features that
--   were chosen by the user. To get informed about changes, listen to
--   "notify<a>fontFeatures</a>".
--   
--   Note that the button will only let users choose font features if
--   <a>FontDialogButton:level</a> is set to
--   <tt>GTK_FONT_LEVEL_FEATURES</tt>.
--   
--   <i>Since: 4.10</i>
fontDialogButtonGetFontFeatures :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> m (Maybe Text)

-- | Returns the language that is used for font features.
--   
--   <i>Since: 4.10</i>
fontDialogButtonGetLanguage :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> m (Maybe Language)

-- | Returns the level of detail at which this dialog lets the user select
--   fonts.
--   
--   <i>Since: 4.10</i>
fontDialogButtonGetLevel :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> m FontLevel

-- | Returns whether the selected font is used in the label.
--   
--   <i>Since: 4.10</i>
fontDialogButtonGetUseFont :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> m Bool

-- | Returns whether the selected font size is used in the label.
--   
--   <i>Since: 4.10</i>
fontDialogButtonGetUseSize :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> m Bool

-- | Creates a new <tt>GtkFontDialogButton</tt> with the given
--   <tt>GtkFontDialog</tt>.
--   
--   You can pass <tt>NULL</tt> to this function and set a
--   <tt>GtkFontDialog</tt> later. The button will be insensitive until
--   that happens.
--   
--   <i>Since: 4.10</i>
fontDialogButtonNew :: (HasCallStack, MonadIO m, IsFontDialog a) => Maybe a -> m FontDialogButton

-- | Sets a <tt>GtkFontDialog</tt> object to use for creating the font
--   chooser dialog that is presented when the user clicks the button.
--   
--   <i>Since: 4.10</i>
fontDialogButtonSetDialog :: (HasCallStack, MonadIO m, IsFontDialogButton a, IsFontDialog b) => a -> b -> m ()

-- | Sets the font of the button.
--   
--   <i>Since: 4.10</i>
fontDialogButtonSetFontDesc :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> FontDescription -> m ()

-- | Sets the font features of the button.
--   
--   <i>Since: 4.10</i>
fontDialogButtonSetFontFeatures :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> Maybe Text -> m ()

-- | Sets the language to use for font features.
--   
--   <i>Since: 4.10</i>
fontDialogButtonSetLanguage :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> Maybe Language -> m ()

-- | Sets the level of detail at which this dialog lets the user select
--   fonts.
--   
--   <i>Since: 4.10</i>
fontDialogButtonSetLevel :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> FontLevel -> m ()

-- | If <i><tt>useFont</tt></i> is <tt>TRUE</tt>, the font name will be
--   written using the selected font.
--   
--   <i>Since: 4.10</i>
fontDialogButtonSetUseFont :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> Bool -> m ()

-- | If <i><tt>useSize</tt></i> is <tt>TRUE</tt>, the font name will be
--   written using the selected font size.
--   
--   <i>Since: 4.10</i>
fontDialogButtonSetUseSize :: (HasCallStack, MonadIO m, IsFontDialogButton a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>dialog</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontDialogButtonDialog :: (IsFontDialogButton o, MonadIO m, IsFontDialog a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>dialog</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialogButton #dialog
--   </pre>
getFontDialogButtonDialog :: (MonadIO m, IsFontDialogButton o) => o -> m (Maybe FontDialog)

-- | Set the value of the “<tt>dialog</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialogButton [ #dialog <a>:=</a> value ]
--   </pre>
setFontDialogButtonDialog :: (MonadIO m, IsFontDialogButton o, IsFontDialog a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-desc</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontDialogButtonFontDesc :: (IsFontDialogButton o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialogButton #fontDesc
--   </pre>
getFontDialogButtonFontDesc :: (MonadIO m, IsFontDialogButton o) => o -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialogButton [ #fontDesc <a>:=</a> value ]
--   </pre>
setFontDialogButtonFontDesc :: (MonadIO m, IsFontDialogButton o) => o -> FontDescription -> m ()

-- | Set the value of the “<tt>font-features</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #fontFeatures
--   </pre>
clearFontDialogButtonFontFeatures :: (MonadIO m, IsFontDialogButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-features</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFontDialogButtonFontFeatures :: (IsFontDialogButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialogButton #fontFeatures
--   </pre>
getFontDialogButtonFontFeatures :: (MonadIO m, IsFontDialogButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialogButton [ #fontFeatures <a>:=</a> value ]
--   </pre>
setFontDialogButtonFontFeatures :: (MonadIO m, IsFontDialogButton o) => o -> Text -> m ()

-- | Set the value of the “<tt>language</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #language
--   </pre>
clearFontDialogButtonLanguage :: (MonadIO m, IsFontDialogButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontDialogButtonLanguage :: (IsFontDialogButton o, MonadIO m) => Language -> m (GValueConstruct o)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialogButton #language
--   </pre>
getFontDialogButtonLanguage :: (MonadIO m, IsFontDialogButton o) => o -> m (Maybe Language)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialogButton [ #language <a>:=</a> value ]
--   </pre>
setFontDialogButtonLanguage :: (MonadIO m, IsFontDialogButton o) => o -> Language -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>level</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontDialogButtonLevel :: (IsFontDialogButton o, MonadIO m) => FontLevel -> m (GValueConstruct o)

-- | Get the value of the “<tt>level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialogButton #level
--   </pre>
getFontDialogButtonLevel :: (MonadIO m, IsFontDialogButton o) => o -> m FontLevel

-- | Set the value of the “<tt>level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialogButton [ #level <a>:=</a> value ]
--   </pre>
setFontDialogButtonLevel :: (MonadIO m, IsFontDialogButton o) => o -> FontLevel -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-font</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontDialogButtonUseFont :: (IsFontDialogButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-font</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialogButton #useFont
--   </pre>
getFontDialogButtonUseFont :: (MonadIO m, IsFontDialogButton o) => o -> m Bool

-- | Set the value of the “<tt>use-font</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialogButton [ #useFont <a>:=</a> value ]
--   </pre>
setFontDialogButtonUseFont :: (MonadIO m, IsFontDialogButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontDialogButtonUseSize :: (IsFontDialogButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialogButton #useSize
--   </pre>
getFontDialogButtonUseSize :: (MonadIO m, IsFontDialogButton o) => o -> m Bool

-- | Set the value of the “<tt>use-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialogButton [ #useSize <a>:=</a> value ]
--   </pre>
setFontDialogButtonUseSize :: (MonadIO m, IsFontDialogButton o) => o -> Bool -> m ()

-- | Emitted when the font dialog button is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkFontDialogButton</tt> is an
--   action signal and emitting it causes the button to pop up its dialog.
--   
--   <i>Since: 4.14</i>
type FontDialogButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fontDialogButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFontDialogButtonActivate :: (IsFontDialogButton a, MonadIO m) => a -> ((?self :: a) => FontDialogButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fontDialogButton #activate callback
--   </pre>
onFontDialogButtonActivate :: (IsFontDialogButton a, MonadIO m) => a -> ((?self :: a) => FontDialogButtonActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.FontDialogButton.FontDialogButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FontDialogButton.FontDialogButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FontDialogButton.FontDialogButton
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FontDialogButton.FontDialogButton o) => GI.Gtk.Objects.FontDialogButton.IsFontDialogButton o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FontDialogButton.FontDialogButton)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FontDialogButton.FontDialogButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FontDialogButton.FontDialogButton


-- | Asynchronous API to present a font chooser dialog.
--   
--   <tt>GtkFontDialog</tt> collects the arguments that are needed to
--   present the dialog to the user, such as a title for the dialog and
--   whether it should be modal.
--   
--   The dialog is shown with the <a>fontDialogChooseFont</a> function or
--   its variants.
--   
--   See <a>FontDialogButton</a> for a convenient control that uses
--   <tt>GtkFontDialog</tt> and presents the results.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.FontDialog

-- | Memory-managed wrapper type.
newtype FontDialog
FontDialog :: ManagedPtr FontDialog -> FontDialog

-- | Type class for types which can be safely cast to <a>FontDialog</a>,
--   for instance with <a>toFontDialog</a>.
class (GObject o, IsDescendantOf FontDialog o) => IsFontDialog o

-- | Cast to <a>FontDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontDialog :: (MonadIO m, IsFontDialog o) => o -> m FontDialog

-- | Presents a font chooser dialog to the user.
--   
--   The font chooser dialog will be set up for selecting a font face.
--   
--   A font face represents a font family and style, but no specific font
--   size.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFace :: (HasCallStack, MonadIO m, IsFontDialog a, IsWindow b, IsFontFace c, IsCancellable d) => a -> Maybe b -> Maybe c -> Maybe d -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fontDialogChooseFace</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFaceFinish :: (HasCallStack, MonadIO m, IsFontDialog a, IsAsyncResult b) => a -> b -> m FontFace

-- | Presents a font chooser dialog to the user.
--   
--   The font chooser dialog will be set up for selecting a font family.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFamily :: (HasCallStack, MonadIO m, IsFontDialog a, IsWindow b, IsFontFamily c, IsCancellable d) => a -> Maybe b -> Maybe c -> Maybe d -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fontDialogChooseFamily</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFamilyFinish :: (HasCallStack, MonadIO m, IsFontDialog a, IsAsyncResult b) => a -> b -> m FontFamily

-- | Presents a font chooser dialog to the user.
--   
--   The font chooser dialog will be set up for selecting a font.
--   
--   If you want to let the user select font features as well, use
--   <a>fontDialogChooseFontAndFeatures</a> instead.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFont :: (HasCallStack, MonadIO m, IsFontDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe FontDescription -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Presents a font chooser dialog to the user.
--   
--   The font chooser dialog will be set up for selecting a font and
--   specify features for the selected font.
--   
--   Font features affect how the font is rendered, for example enabling
--   glyph variants or ligatures.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFontAndFeatures :: (HasCallStack, MonadIO m, IsFontDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe FontDescription -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fontDialogChooseFontAndFeatures</a> call.
--   
--   The selected font and features are returned in
--   <i><tt>fontDesc</tt></i> and <i><tt>fontFeatures</tt></i>.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFontAndFeaturesFinish :: (HasCallStack, MonadIO m, IsFontDialog a, IsAsyncResult b) => a -> b -> m (FontDescription, Text, Language)

-- | Finishes the <a>fontDialogChooseFont</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fontDialogChooseFontFinish :: (HasCallStack, MonadIO m, IsFontDialog a, IsAsyncResult b) => a -> b -> m FontDescription

-- | Returns the filter that decides which fonts to display in the font
--   chooser dialog.
--   
--   <i>Since: 4.10</i>
fontDialogGetFilter :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> m (Maybe Filter)

-- | Returns the fontmap from which fonts are selected, or <tt>NULL</tt>
--   for the default fontmap.
--   
--   <i>Since: 4.10</i>
fontDialogGetFontMap :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> m (Maybe FontMap)

-- | Returns the language for which font features are applied.
--   
--   <i>Since: 4.10</i>
fontDialogGetLanguage :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> m (Maybe Language)

-- | Returns whether the font chooser dialog blocks interaction with the
--   parent window while it is presented.
--   
--   <i>Since: 4.10</i>
fontDialogGetModal :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> m Bool

-- | Returns the title that will be shown on the font chooser dialog.
--   
--   <i>Since: 4.10</i>
fontDialogGetTitle :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> m Text

-- | Creates a new <tt>GtkFontDialog</tt> object.
--   
--   <i>Since: 4.10</i>
fontDialogNew :: (HasCallStack, MonadIO m) => m FontDialog

-- | Adds a filter that decides which fonts to display in the font chooser
--   dialog.
--   
--   The filter must be able to handle both <tt>PangoFontFamily</tt> and
--   <tt>PangoFontFace</tt> objects.
--   
--   <i>Since: 4.10</i>
fontDialogSetFilter :: (HasCallStack, MonadIO m, IsFontDialog a, IsFilter b) => a -> Maybe b -> m ()

-- | Sets the fontmap from which fonts are selected.
--   
--   If <i><tt>fontmap</tt></i> is <tt>NULL</tt>, the default fontmap is
--   used.
--   
--   <i>Since: 4.10</i>
fontDialogSetFontMap :: (HasCallStack, MonadIO m, IsFontDialog a, IsFontMap b) => a -> Maybe b -> m ()

-- | Sets the language for which font features are applied.
--   
--   <i>Since: 4.10</i>
fontDialogSetLanguage :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> Language -> m ()

-- | Sets whether the font chooser dialog blocks interaction with the
--   parent window while it is presented.
--   
--   <i>Since: 4.10</i>
fontDialogSetModal :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> Bool -> m ()

-- | Sets the title that will be shown on the font chooser dialog.
--   
--   <i>Since: 4.10</i>
fontDialogSetTitle :: (HasCallStack, MonadIO m, IsFontDialog a) => a -> Text -> m ()

-- | Set the value of the “<tt>filter</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #filter
--   </pre>
clearFontDialogFilter :: (MonadIO m, IsFontDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontDialogFilter :: (IsFontDialog o, MonadIO m, IsFilter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialog #filter
--   </pre>
getFontDialogFilter :: (MonadIO m, IsFontDialog o) => o -> m (Maybe Filter)

-- | Set the value of the “<tt>filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialog [ #filter <a>:=</a> value ]
--   </pre>
setFontDialogFilter :: (MonadIO m, IsFontDialog o, IsFilter a) => o -> a -> m ()

-- | Set the value of the “<tt>font-map</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #fontMap
--   </pre>
clearFontDialogFontMap :: (MonadIO m, IsFontDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-map</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontDialogFontMap :: (IsFontDialog o, MonadIO m, IsFontMap a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-map</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialog #fontMap
--   </pre>
getFontDialogFontMap :: (MonadIO m, IsFontDialog o) => o -> m (Maybe FontMap)

-- | Set the value of the “<tt>font-map</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialog [ #fontMap <a>:=</a> value ]
--   </pre>
setFontDialogFontMap :: (MonadIO m, IsFontDialog o, IsFontMap a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontDialogLanguage :: (IsFontDialog o, MonadIO m) => Language -> m (GValueConstruct o)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialog #language
--   </pre>
getFontDialogLanguage :: (MonadIO m, IsFontDialog o) => o -> m (Maybe Language)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialog [ #language <a>:=</a> value ]
--   </pre>
setFontDialogLanguage :: (MonadIO m, IsFontDialog o) => o -> Language -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontDialogModal :: (IsFontDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialog #modal
--   </pre>
getFontDialogModal :: (MonadIO m, IsFontDialog o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialog [ #modal <a>:=</a> value ]
--   </pre>
setFontDialogModal :: (MonadIO m, IsFontDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontDialogTitle :: (IsFontDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontDialog #title
--   </pre>
getFontDialogTitle :: (MonadIO m, IsFontDialog o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontDialog [ #title <a>:=</a> value ]
--   </pre>
setFontDialogTitle :: (MonadIO m, IsFontDialog o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.FontDialog.FontDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FontDialog.FontDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FontDialog.FontDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FontDialog.FontDialog o) => GI.Gtk.Objects.FontDialog.IsFontDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FontDialog.FontDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FontDialog.FontDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FontDialog.FontDialog


-- | The <tt>GtkFontChooserWidget</tt> widget lets the user select a font.
--   
--   It is used in the <tt>GtkFontChooserDialog</tt> widget to provide a
--   dialog for selecting fonts.
--   
--   To set the font which is initially selected, use
--   <a>fontChooserSetFont</a> or <a>fontChooserSetFontDesc</a>.
--   
--   To get the selected font use <a>fontChooserGetFont</a> or
--   <a>fontChooserGetFontDesc</a>.
--   
--   To change the text which is shown in the preview area, use
--   <a>fontChooserSetPreviewText</a>.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkFontChooserWidget</tt> has a single CSS node with name
--   fontchooser.
module GI.Gtk.Objects.FontChooserWidget

-- | Memory-managed wrapper type.
newtype FontChooserWidget
FontChooserWidget :: ManagedPtr FontChooserWidget -> FontChooserWidget

-- | Type class for types which can be safely cast to
--   <a>FontChooserWidget</a>, for instance with
--   <a>toFontChooserWidget</a>.
class (GObject o, IsDescendantOf FontChooserWidget o) => IsFontChooserWidget o

-- | Cast to <a>FontChooserWidget</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFontChooserWidget :: (MonadIO m, IsFontChooserWidget o) => o -> m FontChooserWidget

-- | Creates a new <tt>GtkFontChooserWidget</tt>.

-- | <i>Deprecated: (Since version 4.10)Direct use of
--   <tt>GtkFontChooserWidget</tt> is deprecated.</i>
fontChooserWidgetNew :: (HasCallStack, MonadIO m) => m FontChooserWidget

-- | Get the value of the “<tt>tweak-action</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooserWidget #tweakAction
--   </pre>
getFontChooserWidgetTweakAction :: (MonadIO m, IsFontChooserWidget o) => o -> m (Maybe Action)
instance GHC.Classes.Eq GI.Gtk.Objects.FontChooserWidget.FontChooserWidget
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FontChooserWidget.FontChooserWidget
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FontChooserWidget.FontChooserWidget
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FontChooserWidget.FontChooserWidget o) => GI.Gtk.Objects.FontChooserWidget.IsFontChooserWidget o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FontChooserWidget.FontChooserWidget)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FontChooserWidget.FontChooserWidget
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FontChooserWidget.FontChooserWidget


-- | The <tt>GtkFontChooserDialog</tt> widget is a dialog for selecting a
--   font.
--   
--   &lt;picture&gt; &lt;source srcset="fontchooser-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkFontChooserDialog" src="fontchooser.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkFontChooserDialog</tt> implements the <a>FontChooser</a>
--   interface and does not provide much API of its own.
--   
--   To create a <tt>GtkFontChooserDialog</tt>, use
--   <a>fontChooserDialogNew</a>.
--   
--   <h1>GtkFontChooserDialog as GtkBuildable</h1>
--   
--   The <tt>GtkFontChooserDialog</tt> implementation of the
--   <tt>GtkBuildable</tt> interface exposes the buttons with the names
--   “select_button” and “cancel_button”.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkFontChooserDialog</tt> has a single CSS node with the name
--   <tt>window</tt> and style class <tt>.fontchooser</tt>.
module GI.Gtk.Objects.FontChooserDialog

-- | Memory-managed wrapper type.
newtype FontChooserDialog
FontChooserDialog :: ManagedPtr FontChooserDialog -> FontChooserDialog

-- | Type class for types which can be safely cast to
--   <a>FontChooserDialog</a>, for instance with
--   <a>toFontChooserDialog</a>.
class (GObject o, IsDescendantOf FontChooserDialog o) => IsFontChooserDialog o

-- | Cast to <a>FontChooserDialog</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFontChooserDialog :: (MonadIO m, IsFontChooserDialog o) => o -> m FontChooserDialog

-- | Creates a new <tt>GtkFontChooserDialog</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> instead</i>
fontChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m FontChooserDialog
instance GHC.Classes.Eq GI.Gtk.Objects.FontChooserDialog.FontChooserDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FontChooserDialog.FontChooserDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FontChooserDialog.FontChooserDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FontChooserDialog.FontChooserDialog o) => GI.Gtk.Objects.FontChooserDialog.IsFontChooserDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FontChooserDialog.FontChooserDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FontChooserDialog.FontChooserDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FontChooserDialog.FontChooserDialog


-- | The <tt>GtkFontButton</tt> allows to open a font chooser dialog to
--   change the font.
--   
--   &lt;picture&gt; &lt;source srcset="font-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkFontButton" src="font-button.png"&gt; &lt;/picture&gt;
--   
--   It is suitable widget for selecting a font in a preference dialog.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   fontbutton
--   ╰── button.font
--       ╰── [content]
--   </pre>
--   
--   <tt>GtkFontButton</tt> has a single CSS node with name fontbutton
--   which contains a button node with the .font style class.
module GI.Gtk.Objects.FontButton

-- | Memory-managed wrapper type.
newtype FontButton
FontButton :: ManagedPtr FontButton -> FontButton

-- | Type class for types which can be safely cast to <a>FontButton</a>,
--   for instance with <a>toFontButton</a>.
class (GObject o, IsDescendantOf FontButton o) => IsFontButton o

-- | Cast to <a>FontButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontButton :: (MonadIO m, IsFontButton o) => o -> m FontButton

-- | Gets whether the dialog is modal.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonGetModal :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Retrieves the title of the font chooser dialog.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonGetTitle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Text

-- | Returns whether the selected font is used in the label.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonGetUseFont :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Returns whether the selected size is used in the label.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonGetUseSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> m Bool

-- | Creates a new font picker widget.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonNew :: (HasCallStack, MonadIO m) => m FontButton

-- | Creates a new font picker widget showing the given font.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonNewWithFont :: (HasCallStack, MonadIO m) => Text -> m FontButton

-- | Sets whether the dialog should be modal.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonSetModal :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | Sets the title for the font chooser dialog.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonSetTitle :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Text -> m ()

-- | If <i><tt>useFont</tt></i> is <a>True</a>, the font name will be
--   written using the selected font.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonSetUseFont :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | If <i><tt>useSize</tt></i> is <a>True</a>, the font name will be
--   written using the selected size.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialogButton</a>
--   instead</i>
fontButtonSetUseSize :: (HasCallStack, MonadIO m, IsFontButton a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontButtonModal :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #modal
--   </pre>
getFontButtonModal :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #modal <a>:=</a> value ]
--   </pre>
setFontButtonModal :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontButtonTitle :: (IsFontButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #title
--   </pre>
getFontButtonTitle :: (MonadIO m, IsFontButton o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #title <a>:=</a> value ]
--   </pre>
setFontButtonTitle :: (MonadIO m, IsFontButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-font</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontButtonUseFont :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-font</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #useFont
--   </pre>
getFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “<tt>use-font</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #useFont <a>:=</a> value ]
--   </pre>
setFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontButtonUseSize :: (IsFontButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontButton #useSize
--   </pre>
getFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> m Bool

-- | Set the value of the “<tt>use-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontButton [ #useSize <a>:=</a> value ]
--   </pre>
setFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()

-- | Emitted to when the font button is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkFontButton</tt> is an action
--   signal and emitting it causes the button to present its dialog.
--   
--   <i>Since: 4.4</i>
type FontButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fontButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFontButtonActivate :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fontButton #activate callback
--   </pre>
onFontButtonActivate :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonActivateCallback) -> m SignalHandlerId

-- | Emitted when the user selects a font.
--   
--   When handling this signal, use <a>fontChooserGetFont</a> to find out
--   which font was just selected.
--   
--   Note that this signal is only emitted when the user changes the font.
--   If you need to react to programmatic font changes as well, use the
--   notify<a>font</a> signal.
type FontButtonFontSetCallback = IO ()

-- | Connect a signal handler for the <a>fontSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fontButton #fontSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>fontSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fontButton #fontSet callback
--   </pre>
onFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.FontButton.FontButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FontButton.FontButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FontButton.FontButton
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FontButton.FontButton o) => GI.Gtk.Objects.FontButton.IsFontButton o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FontButton.FontButton)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FontButton.FontButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FontButton.FontButton


-- | The kind of widget that can be added to a <tt>GtkFlowBox</tt>.
--   
--   <a>FlowBox</a> will automatically wrap its children in a
--   <tt>GtkFlowBoxChild</tt> when necessary.
module GI.Gtk.Objects.FlowBoxChild

-- | Memory-managed wrapper type.
newtype FlowBoxChild
FlowBoxChild :: ManagedPtr FlowBoxChild -> FlowBoxChild

-- | Type class for types which can be safely cast to <a>FlowBoxChild</a>,
--   for instance with <a>toFlowBoxChild</a>.
class (GObject o, IsDescendantOf FlowBoxChild o) => IsFlowBoxChild o

-- | Cast to <a>FlowBoxChild</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFlowBoxChild :: (MonadIO m, IsFlowBoxChild o) => o -> m FlowBoxChild

-- | Marks <i><tt>child</tt></i> as changed, causing any state that depends
--   on this to be updated.
--   
--   This affects sorting and filtering.
--   
--   Note that calls to this method must be in sync with the data used for
--   the sorting and filtering functions. For instance, if the list is
--   mirroring some external data set, and *two* children changed in the
--   external data set when you call <a>flowBoxChildChanged</a> on the
--   first child, the sort function must only read the new data for the
--   first of the two changed children, otherwise the resorting of the
--   children will be wrong.
--   
--   This generally means that if you don’t fully control the data model,
--   you have to duplicate the data that affects the sorting and filtering
--   functions into the widgets themselves.
--   
--   Another alternative is to call <a>flowBoxInvalidateSort</a> on any
--   model change, but that is more expensive.
flowBoxChildChanged :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m ()

-- | Gets the child widget of <i><tt>self</tt></i>.
flowBoxChildGetChild :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m (Maybe Widget)

-- | Gets the current index of the <i><tt>child</tt></i> in its
--   <tt>GtkFlowBox</tt> container.
flowBoxChildGetIndex :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m Int32

-- | Returns whether the <i><tt>child</tt></i> is currently selected in its
--   <tt>GtkFlowBox</tt> container.
flowBoxChildIsSelected :: (HasCallStack, MonadIO m, IsFlowBoxChild a) => a -> m Bool

-- | Creates a new <tt>GtkFlowBoxChild</tt>.
--   
--   This should only be used as a child of a <tt>GtkFlowBox</tt>.
flowBoxChildNew :: (HasCallStack, MonadIO m) => m FlowBoxChild

-- | Sets the child widget of <i><tt>self</tt></i>.
flowBoxChildSetChild :: (HasCallStack, MonadIO m, IsFlowBoxChild a, IsWidget b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearFlowBoxChildChild :: (MonadIO m, IsFlowBoxChild o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFlowBoxChildChild :: (IsFlowBoxChild o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBoxChild #child
--   </pre>
getFlowBoxChildChild :: (MonadIO m, IsFlowBoxChild o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBoxChild [ #child <a>:=</a> value ]
--   </pre>
setFlowBoxChildChild :: (MonadIO m, IsFlowBoxChild o, IsWidget a) => o -> a -> m ()

-- | Emitted when the user activates a child widget in a
--   <tt>GtkFlowBox</tt>.
--   
--   This can happen either by clicking or double-clicking, or via a
--   keybinding.
--   
--   This is a <a>keybinding signal</a>, but it can be used by applications
--   for their own purposes.
--   
--   The default bindings are &lt;kbd&gt;Space&lt;/kbd&gt; and
--   &lt;kbd&gt;Enter&lt;/kbd&gt;.
type FlowBoxChildActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBoxChild #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxChildActivate :: (IsFlowBoxChild a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBoxChild #activate callback
--   </pre>
onFlowBoxChildActivate :: (IsFlowBoxChild a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.FlowBoxChild.FlowBoxChild
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FlowBoxChild.FlowBoxChild
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FlowBoxChild.FlowBoxChild
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FlowBoxChild.FlowBoxChild o) => GI.Gtk.Objects.FlowBoxChild.IsFlowBoxChild o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FlowBoxChild.FlowBoxChild)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FlowBoxChild.FlowBoxChild
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FlowBoxChild.FlowBoxChild


-- | Puts child widgets in a reflowing grid.
--   
--   &lt;picture&gt; &lt;source srcset="flow-box-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkFlowBox" src="flow-box.png"&gt; &lt;/picture&gt;
--   
--   For instance, with the horizontal orientation, the widgets will be
--   arranged from left to right, starting a new row under the previous row
--   when necessary. Reducing the width in this case will require more
--   rows, so a larger height will be requested.
--   
--   Likewise, with the vertical orientation, the widgets will be arranged
--   from top to bottom, starting a new column to the right when necessary.
--   Reducing the height will require more columns, so a larger width will
--   be requested.
--   
--   The size request of a <tt>GtkFlowBox</tt> alone may not be what you
--   expect; if you need to be able to shrink it along both axes and
--   dynamically reflow its children, you may have to wrap it in a
--   <tt>GtkScrolledWindow</tt> to enable that.
--   
--   The children of a <tt>GtkFlowBox</tt> can be dynamically sorted and
--   filtered.
--   
--   Although a <tt>GtkFlowBox</tt> must have only <tt>GtkFlowBoxChild</tt>
--   children, you can add any kind of widget to it via
--   <a>flowBoxInsert</a>, and a <tt>GtkFlowBoxChild</tt> widget will
--   automatically be inserted between the box and the widget.
--   
--   Also see <a>ListBox</a>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>FlowBox::moveCursor</a></li>
--   <li><a>FlowBox::selectAll</a></li>
--   <li><a>FlowBox::toggleCursorChild</a></li>
--   <li><a>FlowBox::unselectAll</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   flowbox
--   ├── flowboxchild
--   │   ╰── &lt;child&gt;
--   ├── flowboxchild
--   │   ╰── &lt;child&gt;
--   ┊
--   ╰── [rubberband]
--   </pre>
--   
--   <tt>GtkFlowBox</tt> uses a single CSS node with name flowbox.
--   <tt>GtkFlowBoxChild</tt> uses a single CSS node with name
--   flowboxchild. For rubberband selection, a subnode with name rubberband
--   is used.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkFlowBox</tt> uses the <a>AccessibleRoleGrid</a> role, and
--   <tt>GtkFlowBoxChild</tt> uses the <a>AccessibleRoleGridCell</a> role.
module GI.Gtk.Objects.FlowBox

-- | Memory-managed wrapper type.
newtype FlowBox
FlowBox :: ManagedPtr FlowBox -> FlowBox

-- | Type class for types which can be safely cast to <a>FlowBox</a>, for
--   instance with <a>toFlowBox</a>.
class (GObject o, IsDescendantOf FlowBox o) => IsFlowBox o

-- | Cast to <a>FlowBox</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFlowBox :: (MonadIO m, IsFlowBox o) => o -> m FlowBox

-- | Adds <i><tt>child</tt></i> to the end of <i><tt>self</tt></i>.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position.
--   
--   See also: <a>flowBoxInsert</a>.
--   
--   <i>Since: 4.6</i>
flowBoxAppend :: (HasCallStack, MonadIO m, IsFlowBox a, IsWidget b) => a -> b -> m ()

-- | Binds <i><tt>model</tt></i> to <i><tt>box</tt></i>.
--   
--   If <i><tt>box</tt></i> was already bound to a model, that previous
--   binding is destroyed.
--   
--   The contents of <i><tt>box</tt></i> are cleared and then filled with
--   widgets that represent items from <i><tt>model</tt></i>.
--   <i><tt>box</tt></i> is updated whenever <i><tt>model</tt></i> changes.
--   If <i><tt>model</tt></i> is <a>Nothing</a>, <i><tt>box</tt></i> is
--   left empty.
--   
--   It is undefined to add or remove widgets directly (for example, with
--   <a>flowBoxInsert</a>) while <i><tt>box</tt></i> is bound to a model.
--   
--   Note that using a model is incompatible with the filtering and sorting
--   functionality in <tt>GtkFlowBox</tt>. When using a model, filtering
--   and sorting should be implemented by the model.
flowBoxBindModel :: (HasCallStack, MonadIO m, IsFlowBox a, IsListModel b) => a -> Maybe b -> FlowBoxCreateWidgetFunc -> m ()

-- | Returns whether children activate on single clicks.
flowBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Bool

-- | Gets the nth child in the <i><tt>box</tt></i>.
flowBoxGetChildAtIndex :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Int32 -> m (Maybe FlowBoxChild)

-- | Gets the child in the (<i><tt>x</tt></i>, <i><tt>y</tt></i>) position.
--   
--   Both <i><tt>x</tt></i> and <i><tt>y</tt></i> are assumed to be
--   relative to the origin of <i><tt>box</tt></i>.
flowBoxGetChildAtPos :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Int32 -> Int32 -> m (Maybe FlowBoxChild)

-- | Gets the horizontal spacing.
flowBoxGetColumnSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Returns whether the box is homogeneous.
flowBoxGetHomogeneous :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Bool

-- | Gets the maximum number of children per line.
flowBoxGetMaxChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Gets the minimum number of children per line.
flowBoxGetMinChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Gets the vertical spacing.
flowBoxGetRowSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m Word32

-- | Creates a list of all selected children.
flowBoxGetSelectedChildren :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m [FlowBoxChild]

-- | Gets the selection mode of <i><tt>box</tt></i>.
flowBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m SelectionMode

-- | Inserts the <i><tt>widget</tt></i> into <i><tt>box</tt></i> at
--   <i><tt>position</tt></i>.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position.
--   
--   If <i><tt>position</tt></i> is -1, or larger than the total number of
--   children in the <i><tt>box</tt></i>, then the <i><tt>widget</tt></i>
--   will be appended to the end.
flowBoxInsert :: (HasCallStack, MonadIO m, IsFlowBox a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Updates the filtering for all children.
--   
--   Call this function when the result of the filter function on the
--   <i><tt>box</tt></i> is changed due to an external factor. For
--   instance, this would be used if the filter function just looked for a
--   specific search term, and the entry with the string has changed.
flowBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Updates the sorting for all children.
--   
--   Call this when the result of the sort function on <i><tt>box</tt></i>
--   is changed due to an external factor.
flowBoxInvalidateSort :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Creates a <tt>GtkFlowBox</tt>.
flowBoxNew :: (HasCallStack, MonadIO m) => m FlowBox

-- | Adds <i><tt>child</tt></i> to the start of <i><tt>self</tt></i>.
--   
--   If a sort function is set, the widget will actually be inserted at the
--   calculated position.
--   
--   See also: <a>flowBoxInsert</a>.
--   
--   <i>Since: 4.6</i>
flowBoxPrepend :: (HasCallStack, MonadIO m, IsFlowBox a, IsWidget b) => a -> b -> m ()

-- | Removes a child from <i><tt>box</tt></i>.
flowBoxRemove :: (HasCallStack, MonadIO m, IsFlowBox a, IsWidget b) => a -> b -> m ()

-- | Removes all children from <i><tt>box</tt></i>.
--   
--   This function does nothing if <i><tt>box</tt></i> is backed by a
--   model.
--   
--   <i>Since: 4.12</i>
flowBoxRemoveAll :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Select all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
flowBoxSelectAll :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Selects a single child of <i><tt>box</tt></i>, if the selection mode
--   allows it.
flowBoxSelectChild :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => a -> b -> m ()

-- | Calls a function for each selected child.
--   
--   Note that the selection cannot be modified from within this function.
flowBoxSelectedForeach :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> FlowBoxForeachFunc -> m ()

-- | If <i><tt>single</tt></i> is <a>True</a>, children will be activated
--   when you click on them, otherwise you need to double-click.
flowBoxSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Bool -> m ()

-- | Sets the horizontal space to add between children.
flowBoxSetColumnSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | By setting a filter function on the <i><tt>box</tt></i> one can decide
--   dynamically which of the children to show.
--   
--   For instance, to implement a search function that only shows the
--   children matching the search terms.
--   
--   The <i><tt>filterFunc</tt></i> will be called for each child after the
--   call, and it will continue to be called each time a child changes (via
--   <a>flowBoxChildChanged</a>) or when <a>flowBoxInvalidateFilter</a> is
--   called.
--   
--   Note that using a filter function is incompatible with using a model
--   (see <a>flowBoxBindModel</a>).
flowBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxFilterFunc -> m ()

-- | Hooks up an adjustment to focus handling in <i><tt>box</tt></i>.
--   
--   The adjustment is also used for autoscrolling during rubberband
--   selection. See <a>scrolledWindowGetHadjustment</a> for a typical way
--   of obtaining the adjustment, and <a>flowBoxSetVadjustment</a> for
--   setting the vertical adjustment.
--   
--   The adjustments have to be in pixel units and in the same coordinate
--   system as the allocation for immediate children of the box.
flowBoxSetHadjustment :: (HasCallStack, MonadIO m, IsFlowBox a, IsAdjustment b) => a -> b -> m ()

-- | Sets whether or not all children of <i><tt>box</tt></i> are given
--   equal space in the box.
flowBoxSetHomogeneous :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Bool -> m ()

-- | Sets the maximum number of children to request and allocate space for
--   in <i><tt>box</tt></i>’s orientation.
--   
--   Setting the maximum number of children per line limits the overall
--   natural size request to be no more than <i><tt>nChildren</tt></i>
--   children long in the given orientation.
flowBoxSetMaxChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets the minimum number of children to line up in
--   <i><tt>box</tt></i>’s orientation before flowing.
flowBoxSetMinChildrenPerLine :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets the vertical space to add between children.
flowBoxSetRowSpacing :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Word32 -> m ()

-- | Sets how selection works in <i><tt>box</tt></i>.
flowBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> SelectionMode -> m ()

-- | By setting a sort function on the <i><tt>box</tt></i>, one can
--   dynamically reorder the children of the box, based on the contents of
--   the children.
--   
--   The <i><tt>sortFunc</tt></i> will be called for each child after the
--   call, and will continue to be called each time a child changes (via
--   <a>flowBoxChildChanged</a>) and when <a>flowBoxInvalidateSort</a> is
--   called.
--   
--   Note that using a sort function is incompatible with using a model
--   (see <a>flowBoxBindModel</a>).
flowBoxSetSortFunc :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> Maybe FlowBoxSortFunc -> m ()

-- | Hooks up an adjustment to focus handling in <i><tt>box</tt></i>.
--   
--   The adjustment is also used for autoscrolling during rubberband
--   selection. See <a>scrolledWindowGetVadjustment</a> for a typical way
--   of obtaining the adjustment, and <a>flowBoxSetHadjustment</a> for
--   setting the horizontal adjustment.
--   
--   The adjustments have to be in pixel units and in the same coordinate
--   system as the allocation for immediate children of the box.
flowBoxSetVadjustment :: (HasCallStack, MonadIO m, IsFlowBox a, IsAdjustment b) => a -> b -> m ()

-- | Unselect all children of <i><tt>box</tt></i>, if the selection mode
--   allows it.
flowBoxUnselectAll :: (HasCallStack, MonadIO m, IsFlowBox a) => a -> m ()

-- | Unselects a single child of <i><tt>box</tt></i>, if the selection mode
--   allows it.
flowBoxUnselectChild :: (HasCallStack, MonadIO m, IsFlowBox a, IsFlowBoxChild b) => a -> b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accept-unpaired-release</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFlowBoxAcceptUnpairedRelease :: (IsFlowBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>accept-unpaired-release</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #acceptUnpairedRelease
--   </pre>
getFlowBoxAcceptUnpairedRelease :: (MonadIO m, IsFlowBox o) => o -> m Bool

-- | Set the value of the “<tt>accept-unpaired-release</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #acceptUnpairedRelease <a>:=</a> value ]
--   </pre>
setFlowBoxAcceptUnpairedRelease :: (MonadIO m, IsFlowBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activate-on-single-click</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFlowBoxActivateOnSingleClick :: (IsFlowBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #activateOnSingleClick
--   </pre>
getFlowBoxActivateOnSingleClick :: (MonadIO m, IsFlowBox o) => o -> m Bool

-- | Set the value of the “<tt>activate-on-single-click</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #activateOnSingleClick <a>:=</a> value ]
--   </pre>
setFlowBoxActivateOnSingleClick :: (MonadIO m, IsFlowBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>column-spacing</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFlowBoxColumnSpacing :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #columnSpacing
--   </pre>
getFlowBoxColumnSpacing :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>column-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #columnSpacing <a>:=</a> value ]
--   </pre>
setFlowBoxColumnSpacing :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>homogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFlowBoxHomogeneous :: (IsFlowBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #homogeneous
--   </pre>
getFlowBoxHomogeneous :: (MonadIO m, IsFlowBox o) => o -> m Bool

-- | Set the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #homogeneous <a>:=</a> value ]
--   </pre>
setFlowBoxHomogeneous :: (MonadIO m, IsFlowBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-children-per-line</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFlowBoxMaxChildrenPerLine :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #maxChildrenPerLine
--   </pre>
getFlowBoxMaxChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>max-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #maxChildrenPerLine <a>:=</a> value ]
--   </pre>
setFlowBoxMaxChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>min-children-per-line</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFlowBoxMinChildrenPerLine :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>min-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #minChildrenPerLine
--   </pre>
getFlowBoxMinChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>min-children-per-line</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #minChildrenPerLine <a>:=</a> value ]
--   </pre>
setFlowBoxMinChildrenPerLine :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-spacing</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFlowBoxRowSpacing :: (IsFlowBox o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #rowSpacing
--   </pre>
getFlowBoxRowSpacing :: (MonadIO m, IsFlowBox o) => o -> m Word32

-- | Set the value of the “<tt>row-spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #rowSpacing <a>:=</a> value ]
--   </pre>
setFlowBoxRowSpacing :: (MonadIO m, IsFlowBox o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selection-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFlowBoxSelectionMode :: (IsFlowBox o, MonadIO m) => SelectionMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flowBox #selectionMode
--   </pre>
getFlowBoxSelectionMode :: (MonadIO m, IsFlowBox o) => o -> m SelectionMode

-- | Set the value of the “<tt>selection-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flowBox [ #selectionMode <a>:=</a> value ]
--   </pre>
setFlowBoxSelectionMode :: (MonadIO m, IsFlowBox o) => o -> SelectionMode -> m ()

-- | Emitted when the user activates the <i><tt>box</tt></i>.
--   
--   This is a <a>keybinding signal</a>.
type FlowBoxActivateCursorChildCallback = IO ()

-- | Connect a signal handler for the <a>activateCursorChild</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #activateCursorChild callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxActivateCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxActivateCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateCursorChild</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #activateCursorChild callback
--   </pre>
onFlowBoxActivateCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxActivateCursorChildCallback) -> m SignalHandlerId

-- | Emitted when a child has been activated by the user.
type FlowBoxChildActivatedCallback = FlowBoxChild -> IO ()

-- | Connect a signal handler for the <a>childActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #childActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxChildActivated :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>childActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #childActivated callback
--   </pre>
onFlowBoxChildActivated :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxChildActivatedCallback) -> m SignalHandlerId

-- | Emitted when the user initiates a cursor movement.
--   
--   This is a <a>keybinding signal</a>. Applications should not connect to
--   it, but may emit it with <tt><i>g_signal_emit_by_name()</i></tt> if
--   they need to control the cursor programmatically.
--   
--   The default bindings for this signal come in two variants, the variant
--   with the Shift modifier extends the selection, the variant without the
--   Shift modifier does not. There are too many key combinations to list
--   them all here.
--   
--   <ul>
--   <li>&lt;kbd&gt;←&lt;/kbd&gt;, &lt;kbd&gt;→&lt;/kbd&gt;,
--   &lt;kbd&gt;↑&lt;/kbd&gt;, &lt;kbd&gt;↓&lt;/kbd&gt; move by individual
--   children</li>
--   <li>&lt;kbd&gt;Home&lt;/kbd&gt;, &lt;kbd&gt;End&lt;/kbd&gt; move to
--   the ends of the box</li>
--   <li>&lt;kbd&gt;PgUp&lt;/kbd&gt;, &lt;kbd&gt;PgDn&lt;/kbd&gt; move
--   vertically by pages</li>
--   </ul>
type FlowBoxMoveCursorCallback = MovementStep -> Int32 -> Bool -> Bool -> IO Bool

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #moveCursor callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxMoveCursor :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxMoveCursorCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveCursor</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #moveCursor callback
--   </pre>
onFlowBoxMoveCursor :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxMoveCursorCallback) -> m SignalHandlerId

-- | Emitted to select all children of the box, if the selection mode
--   permits it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
type FlowBoxSelectAllCallback = IO ()

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #selectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxSelectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #selectAll callback
--   </pre>
onFlowBoxSelectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectAllCallback) -> m SignalHandlerId

-- | Emitted when the set of selected children changes.
--   
--   Use <a>flowBoxSelectedForeach</a> or <a>flowBoxGetSelectedChildren</a>
--   to obtain the selected children.
type FlowBoxSelectedChildrenChangedCallback = IO ()

-- | Connect a signal handler for the <a>selectedChildrenChanged</a>
--   signal, to be run after the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #selectedChildrenChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxSelectedChildrenChanged :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectedChildrenChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>selectedChildrenChanged</a>
--   signal, to be run before the default handler. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #selectedChildrenChanged callback
--   </pre>
onFlowBoxSelectedChildrenChanged :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxSelectedChildrenChangedCallback) -> m SignalHandlerId

-- | Emitted to toggle the selection of the child that has the focus.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Space&lt;/kbd&gt;.
type FlowBoxToggleCursorChildCallback = IO ()

-- | Connect a signal handler for the <a>toggleCursorChild</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #toggleCursorChild callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxToggleCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxToggleCursorChildCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggleCursorChild</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #toggleCursorChild callback
--   </pre>
onFlowBoxToggleCursorChild :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxToggleCursorChildCallback) -> m SignalHandlerId

-- | Emitted to unselect all children of the box, if the selection mode
--   permits it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default bindings for this signal is
--   &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;Shift&lt;/kbd&gt;-&lt;kbd&gt;a&lt;/kbd&gt;.
type FlowBoxUnselectAllCallback = IO ()

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> flowBox #unselectAll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFlowBoxUnselectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxUnselectAllCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unselectAll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> flowBox #unselectAll callback
--   </pre>
onFlowBoxUnselectAll :: (IsFlowBox a, MonadIO m) => a -> ((?self :: a) => FlowBoxUnselectAllCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.FlowBox.FlowBox
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FlowBox.FlowBox
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FlowBox.FlowBox
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FlowBox.FlowBox o) => GI.Gtk.Objects.FlowBox.IsFlowBox o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FlowBox.FlowBox)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FlowBox.FlowBox
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FlowBox.FlowBox


-- | <tt>GtkLayoutChild</tt> subclass for children in a
--   <tt>GtkFixedLayout</tt>.
module GI.Gtk.Objects.FixedLayoutChild

-- | Memory-managed wrapper type.
newtype FixedLayoutChild
FixedLayoutChild :: ManagedPtr FixedLayoutChild -> FixedLayoutChild

-- | Type class for types which can be safely cast to
--   <a>FixedLayoutChild</a>, for instance with <a>toFixedLayoutChild</a>.
class (GObject o, IsDescendantOf FixedLayoutChild o) => IsFixedLayoutChild o

-- | Cast to <a>FixedLayoutChild</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFixedLayoutChild :: (MonadIO m, IsFixedLayoutChild o) => o -> m FixedLayoutChild

-- | Retrieves the transformation of the child.
fixedLayoutChildGetTransform :: (HasCallStack, MonadIO m, IsFixedLayoutChild a) => a -> m (Maybe Transform)

-- | Sets the transformation of the child of a <tt>GtkFixedLayout</tt>.
fixedLayoutChildSetTransform :: (HasCallStack, MonadIO m, IsFixedLayoutChild a) => a -> Transform -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>transform</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFixedLayoutChildTransform :: (IsFixedLayoutChild o, MonadIO m) => Transform -> m (GValueConstruct o)

-- | Get the value of the “<tt>transform</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fixedLayoutChild #transform
--   </pre>
getFixedLayoutChildTransform :: (MonadIO m, IsFixedLayoutChild o) => o -> m (Maybe Transform)

-- | Set the value of the “<tt>transform</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fixedLayoutChild [ #transform <a>:=</a> value ]
--   </pre>
setFixedLayoutChildTransform :: (MonadIO m, IsFixedLayoutChild o) => o -> Transform -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.FixedLayoutChild.FixedLayoutChild
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FixedLayoutChild.FixedLayoutChild
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FixedLayoutChild.FixedLayoutChild
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FixedLayoutChild.FixedLayoutChild o) => GI.Gtk.Objects.FixedLayoutChild.IsFixedLayoutChild o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FixedLayoutChild.FixedLayoutChild)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FixedLayoutChild.FixedLayoutChild
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FixedLayoutChild.FixedLayoutChild


-- | Places child widgets at fixed positions.
--   
--   Most applications should never use this layout manager; fixed
--   positioning and sizing requires constant recalculations on where
--   children need to be positioned and sized. Other layout managers
--   perform this kind of work internally so that application developers
--   don't need to do it. Specifically, widgets positioned in a fixed
--   layout manager will need to take into account:
--   
--   <ul>
--   <li>Themes, which may change widget sizes.</li>
--   <li>Fonts other than the one you used to write the app will of course
--   change the size of widgets containing text; keep in mind that users
--   may use a larger font because of difficulty reading the default, or
--   they may be using a different OS that provides different fonts.</li>
--   <li>Translation of text into other languages changes its size. Also,
--   display of non-English text will use a different font in many
--   cases.</li>
--   </ul>
--   
--   In addition, <tt>GtkFixedLayout</tt> does not pay attention to text
--   direction and thus may produce unwanted results if your app is run
--   under right-to-left languages such as Hebrew or Arabic. That is:
--   normally GTK will order containers appropriately depending on the text
--   direction, e.g. to put labels to the right of the thing they label
--   when using an RTL language; <tt>GtkFixedLayout</tt> won't be able to
--   do that for you.
--   
--   Finally, fixed positioning makes it kind of annoying to add/remove UI
--   elements, since you have to reposition all the other elements. This is
--   a long-term maintenance problem for your application.
module GI.Gtk.Objects.FixedLayout

-- | Memory-managed wrapper type.
newtype FixedLayout
FixedLayout :: ManagedPtr FixedLayout -> FixedLayout

-- | Type class for types which can be safely cast to <a>FixedLayout</a>,
--   for instance with <a>toFixedLayout</a>.
class (GObject o, IsDescendantOf FixedLayout o) => IsFixedLayout o

-- | Cast to <a>FixedLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFixedLayout :: (MonadIO m, IsFixedLayout o) => o -> m FixedLayout

-- | Creates a new <tt>GtkFixedLayout</tt>.
fixedLayoutNew :: (HasCallStack, MonadIO m) => m FixedLayout
instance GHC.Classes.Eq GI.Gtk.Objects.FixedLayout.FixedLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FixedLayout.FixedLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FixedLayout.FixedLayout
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FixedLayout.FixedLayout o) => GI.Gtk.Objects.FixedLayout.IsFixedLayout o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FixedLayout.FixedLayout)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FixedLayout.FixedLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FixedLayout.FixedLayout


-- | Places its child widgets at fixed positions and with fixed sizes.
--   
--   <tt>GtkFixed</tt> performs no automatic layout management.
--   
--   For most applications, you should not use this container! It keeps you
--   from having to learn about the other GTK containers, but it results in
--   broken applications. With <tt>GtkFixed</tt>, the following things will
--   result in truncated text, overlapping widgets, and other display bugs:
--   
--   <ul>
--   <li>Themes, which may change widget sizes.</li>
--   <li>Fonts other than the one you used to write the app will of course
--   change the size of widgets containing text; keep in mind that users
--   may use a larger font because of difficulty reading the default, or
--   they may be using a different OS that provides different fonts.</li>
--   <li>Translation of text into other languages changes its size. Also,
--   display of non-English text will use a different font in many
--   cases.</li>
--   </ul>
--   
--   In addition, <tt>GtkFixed</tt> does not pay attention to text
--   direction and thus may produce unwanted results if your app is run
--   under right-to-left languages such as Hebrew or Arabic. That is:
--   normally GTK will order containers appropriately for the text
--   direction, e.g. to put labels to the right of the thing they label
--   when using an RTL language, but it can’t do that with
--   <tt>GtkFixed</tt>. So if you need to reorder widgets depending on the
--   text direction, you would need to manually detect it and adjust child
--   positions accordingly.
--   
--   Finally, fixed positioning makes it kind of annoying to add/remove UI
--   elements, since you have to reposition all the other elements. This is
--   a long-term maintenance problem for your application.
--   
--   If you know none of these things are an issue for your application,
--   and prefer the simplicity of <tt>GtkFixed</tt>, by all means use the
--   widget. But you should be aware of the tradeoffs.
module GI.Gtk.Objects.Fixed

-- | Memory-managed wrapper type.
newtype Fixed
Fixed :: ManagedPtr Fixed -> Fixed

-- | Type class for types which can be safely cast to <a>Fixed</a>, for
--   instance with <a>toFixed</a>.
class (GObject o, IsDescendantOf Fixed o) => IsFixed o

-- | Cast to <a>Fixed</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFixed :: (MonadIO m, IsFixed o) => o -> m Fixed

-- | Retrieves the translation transformation of the given child
--   <tt>GtkWidget</tt> in the <tt>GtkFixed</tt>.
--   
--   See also: <a>fixedGetChildTransform</a>.
fixedGetChildPosition :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> m (Double, Double)

-- | Retrieves the transformation for <i><tt>widget</tt></i> set using
--   <a>fixedSetChildTransform</a>.
fixedGetChildTransform :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> m (Maybe Transform)

-- | Sets a translation transformation to the given <i><tt>x</tt></i> and
--   <i><tt>y</tt></i> coordinates to the child <i><tt>widget</tt></i> of
--   the <tt>GtkFixed</tt>.
fixedMove :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> Double -> Double -> m ()

-- | Creates a new <tt>GtkFixed</tt>.
fixedNew :: (HasCallStack, MonadIO m) => m Fixed

-- | Adds a widget to a <tt>GtkFixed</tt> at the given position.
fixedPut :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> Double -> Double -> m ()

-- | Removes a child from <i><tt>fixed</tt></i>.
fixedRemove :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> m ()

-- | Sets the transformation for <i><tt>widget</tt></i>.
--   
--   This is a convenience function that retrieves the
--   <a>FixedLayoutChild</a> instance associated to <i><tt>widget</tt></i>
--   and calls <a>fixedLayoutChildSetTransform</a>.
fixedSetChildTransform :: (HasCallStack, MonadIO m, IsFixed a, IsWidget b) => a -> b -> Maybe Transform -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Fixed.Fixed
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Fixed.Fixed
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Fixed.Fixed
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Fixed.Fixed o) => GI.Gtk.Objects.Fixed.IsFixed o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Fixed.Fixed)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Fixed.Fixed
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Fixed.Fixed


-- | Asynchronous API to open a file with an application.
--   
--   <tt>GtkFileLauncher</tt> collects the arguments that are needed to
--   open the file.
--   
--   Depending on system configuration, user preferences and available
--   APIs, this may or may not show an app chooser dialog or launch the
--   default application right away.
--   
--   The operation is started with the <a>fileLauncherLaunch</a> function.
--   
--   To launch uris that don't represent files, use <a>UriLauncher</a>.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.FileLauncher

-- | Memory-managed wrapper type.
newtype FileLauncher
FileLauncher :: ManagedPtr FileLauncher -> FileLauncher

-- | Type class for types which can be safely cast to <a>FileLauncher</a>,
--   for instance with <a>toFileLauncher</a>.
class (GObject o, IsDescendantOf FileLauncher o) => IsFileLauncher o

-- | Cast to <a>FileLauncher</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFileLauncher :: (MonadIO m, IsFileLauncher o) => o -> m FileLauncher

-- | Returns whether to ask the user which app to use.
--   
--   <i>Since: 4.12</i>
fileLauncherGetAlwaysAsk :: (HasCallStack, MonadIO m, IsFileLauncher a) => a -> m Bool

-- | Gets the file that will be opened.
--   
--   <i>Since: 4.10</i>
fileLauncherGetFile :: (HasCallStack, MonadIO m, IsFileLauncher a) => a -> m (Maybe File)

-- | Returns whether to make the file writable for the handler.
--   
--   <i>Since: 4.14</i>
fileLauncherGetWritable :: (HasCallStack, MonadIO m, IsFileLauncher a) => a -> m Bool

-- | Launches an application to open the file.
--   
--   This may present an app chooser dialog to the user.
--   
--   <i>Since: 4.10</i>
fileLauncherLaunch :: (HasCallStack, MonadIO m, IsFileLauncher a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileLauncherLaunch</a> call and returns the result.
--   
--   <i>Since: 4.10</i>
fileLauncherLaunchFinish :: (HasCallStack, MonadIO m, IsFileLauncher a, IsAsyncResult b) => a -> b -> m ()

-- | Creates a new <tt>GtkFileLauncher</tt> object.
--   
--   <i>Since: 4.10</i>
fileLauncherNew :: (HasCallStack, MonadIO m, IsFile a) => Maybe a -> m FileLauncher

-- | Launches a file manager to show the file in its parent directory.
--   
--   This is only supported for native files. It will fail if
--   <i><tt>file</tt></i> is e.g. a http:// uri.
--   
--   <i>Since: 4.10</i>
fileLauncherOpenContainingFolder :: (HasCallStack, MonadIO m, IsFileLauncher a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileLauncherOpenContainingFolder</a> call and returns
--   the result.
--   
--   <i>Since: 4.10</i>
fileLauncherOpenContainingFolderFinish :: (HasCallStack, MonadIO m, IsFileLauncher a, IsAsyncResult b) => a -> b -> m ()

-- | Sets whether to always ask the user which app to use.
--   
--   If false, the file might be opened with a default app or the previous
--   choice.
--   
--   <i>Since: 4.12</i>
fileLauncherSetAlwaysAsk :: (HasCallStack, MonadIO m, IsFileLauncher a) => a -> Bool -> m ()

-- | Sets the file that will be opened.
--   
--   <i>Since: 4.10</i>
fileLauncherSetFile :: (HasCallStack, MonadIO m, IsFileLauncher a, IsFile b) => a -> Maybe b -> m ()

-- | Sets whether to make the file writable for the handler.
--   
--   <i>Since: 4.14</i>
fileLauncherSetWritable :: (HasCallStack, MonadIO m, IsFileLauncher a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>always-ask</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFileLauncherAlwaysAsk :: (IsFileLauncher o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>always-ask</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileLauncher #alwaysAsk
--   </pre>
getFileLauncherAlwaysAsk :: (MonadIO m, IsFileLauncher o) => o -> m Bool

-- | Set the value of the “<tt>always-ask</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileLauncher [ #alwaysAsk <a>:=</a> value ]
--   </pre>
setFileLauncherAlwaysAsk :: (MonadIO m, IsFileLauncher o) => o -> Bool -> m ()

-- | Set the value of the “<tt>file</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #file
--   </pre>
clearFileLauncherFile :: (MonadIO m, IsFileLauncher o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileLauncherFile :: (IsFileLauncher o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileLauncher #file
--   </pre>
getFileLauncherFile :: (MonadIO m, IsFileLauncher o) => o -> m (Maybe File)

-- | Set the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileLauncher [ #file <a>:=</a> value ]
--   </pre>
setFileLauncherFile :: (MonadIO m, IsFileLauncher o, IsFile a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>writable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFileLauncherWritable :: (IsFileLauncher o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>writable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileLauncher #writable
--   </pre>
getFileLauncherWritable :: (MonadIO m, IsFileLauncher o) => o -> m Bool

-- | Set the value of the “<tt>writable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileLauncher [ #writable <a>:=</a> value ]
--   </pre>
setFileLauncherWritable :: (MonadIO m, IsFileLauncher o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.FileLauncher.FileLauncher
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FileLauncher.FileLauncher
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FileLauncher.FileLauncher
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FileLauncher.FileLauncher o) => GI.Gtk.Objects.FileLauncher.IsFileLauncher o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FileLauncher.FileLauncher)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FileLauncher.FileLauncher
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FileLauncher.FileLauncher


-- | Asynchronous API to present a file chooser dialog.
--   
--   <tt>GtkFileDialog</tt> collects the arguments that are needed to
--   present the dialog to the user, such as a title for the dialog and
--   whether it should be modal.
--   
--   The dialog is shown with <a>fileDialogOpen</a>, <a>fileDialogSave</a>,
--   etc.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.FileDialog

-- | Memory-managed wrapper type.
newtype FileDialog
FileDialog :: ManagedPtr FileDialog -> FileDialog

-- | Type class for types which can be safely cast to <a>FileDialog</a>,
--   for instance with <a>toFileDialog</a>.
class (GObject o, IsDescendantOf FileDialog o) => IsFileDialog o

-- | Cast to <a>FileDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFileDialog :: (MonadIO m, IsFileDialog o) => o -> m FileDialog

-- | Retrieves the text used by the dialog on its accept button.
--   
--   <i>Since: 4.10</i>
fileDialogGetAcceptLabel :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m (Maybe Text)

-- | Gets the filter that will be selected by default in the file chooser
--   dialog.
--   
--   <i>Since: 4.10</i>
fileDialogGetDefaultFilter :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m (Maybe FileFilter)

-- | Gets the filters that will be offered to the user in the file chooser
--   dialog.
--   
--   <i>Since: 4.10</i>
fileDialogGetFilters :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m (Maybe ListModel)

-- | Gets the file that will be initially selected in the file chooser
--   dialog.
--   
--   <i>Since: 4.10</i>
fileDialogGetInitialFile :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m (Maybe File)

-- | Gets the folder that will be set as the initial folder in the file
--   chooser dialog.
--   
--   <i>Since: 4.10</i>
fileDialogGetInitialFolder :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m (Maybe File)

-- | Gets the filename that will be initially selected.
--   
--   <i>Since: 4.10</i>
fileDialogGetInitialName :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m (Maybe Text)

-- | Returns whether the file chooser dialog blocks interaction with the
--   parent window while it is presented.
--   
--   <i>Since: 4.10</i>
fileDialogGetModal :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m Bool

-- | Returns the title that will be shown on the file chooser dialog.
--   
--   <i>Since: 4.10</i>
fileDialogGetTitle :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> m Text

-- | Creates a new <tt>GtkFileDialog</tt> object.
--   
--   <i>Since: 4.10</i>
fileDialogNew :: (HasCallStack, MonadIO m) => m FileDialog

-- | Presents a file chooser dialog to the user.
--   
--   The file chooser dialog will be set up to select a single file.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.10</i>
fileDialogOpen :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogOpen</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fileDialogOpenFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m File

-- | Presents a file chooser dialog to the user.
--   
--   The file chooser dialog will be set up to select multiple files.
--   
--   The file chooser dialog will initially be opened in the directory
--   <a>FileDialog:initialFolder</a>.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.10</i>
fileDialogOpenMultiple :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogOpen</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fileDialogOpenMultipleFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m ListModel

-- | Presents a file chooser dialog to the user.
--   
--   The file chooser dialog will be set up to select multiple files.
--   
--   The file chooser dialog will initially be opened in the directory
--   <a>FileDialog:initialFolder</a>.
--   
--   In contrast to <a>fileDialogOpen</a>, this function lets the user
--   select the text encoding for the files, if possible.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.18</i>
fileDialogOpenMultipleTextFiles :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogOpen</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.18</i>
fileDialogOpenMultipleTextFilesFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m (ListModel, Text)

-- | Initiates a file selection operation by presenting a file chooser
--   dialog to the user.
--   
--   In contrast to <a>fileDialogOpen</a>, this function lets the user
--   select the text encoding for the file, if possible.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.18</i>
fileDialogOpenTextFile :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogOpenTextFile</a> call and returns the
--   resulting file and text encoding.
--   
--   If the user has explicitly selected a text encoding to use for the
--   file, then <i><tt>encoding</tt></i> will be set to a codeset name that
--   is suitable for passing to <tt><i>iconv_open()</i></tt>. Otherwise, it
--   will be <tt>NULL</tt>.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.18</i>
fileDialogOpenTextFileFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m (File, Text)

-- | Presents a file chooser dialog to the user.
--   
--   The file chooser dialog will be save mode.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.10</i>
fileDialogSave :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogSave</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fileDialogSaveFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m File

-- | Initiates a file save operation by presenting a file chooser dialog to
--   the user.
--   
--   In contrast to <a>fileDialogSave</a>, this function lets the user
--   select the text encoding and line endings for the text file, if
--   possible.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.18</i>
fileDialogSaveTextFile :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogSaveTextFile</a> call and returns the
--   resulting file, text encoding and line endings.
--   
--   If the user has explicitly selected a text encoding to use for the
--   file, then <i><tt>encoding</tt></i> will be set to a codeset name that
--   is suitable for passing to <tt><i>iconv_open()</i></tt>. Otherwise, it
--   will be <tt>NULL</tt>.
--   
--   The <i><tt>lineEnding</tt></i> will be set to one of "\n", "\r\n",
--   "\r" or "", where the latter means to preserve existing line endings.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.18</i>
fileDialogSaveTextFileFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m (File, Text, Text)

-- | Presents a file chooser dialog to the user.
--   
--   The file chooser dialog will be set up to select a single folder.
--   
--   If you pass <i><tt>initialFolder</tt></i>, the file chooser dialog
--   will initially be opened in the parent directory of that folder,
--   otherwise, it will be in the directory
--   <a>FileDialog:initialFolder</a>.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.10</i>
fileDialogSelectFolder :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogSelectFolder</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fileDialogSelectFolderFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m File

-- | Presents a file chooser dialog to the user.
--   
--   The file chooser dialog will be set up to allow selecting multiple
--   folders.
--   
--   The file chooser dialog will initially be opened in the directory
--   <a>FileDialog:initialFolder</a>.
--   
--   The <i><tt>callback</tt></i> will be called when the dialog is closed.
--   
--   <i>Since: 4.10</i>
fileDialogSelectMultipleFolders :: (HasCallStack, MonadIO m, IsFileDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>fileDialogSelectMultipleFolders</a> call.
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
fileDialogSelectMultipleFoldersFinish :: (HasCallStack, MonadIO m, IsFileDialog a, IsAsyncResult b) => a -> b -> m ListModel

-- | Sets the label shown on the file chooser's accept button.
--   
--   Leaving the accept label unset or setting it as <tt>NULL</tt> will
--   fall back to a default label, depending on what API is used to launch
--   the file dialog.
--   
--   <i>Since: 4.10</i>
fileDialogSetAcceptLabel :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> Maybe Text -> m ()

-- | Sets the filter that will be selected by default in the file chooser
--   dialog.
--   
--   If set to <tt>NULL</tt>, the first item in <a>FileDialog:filters</a>
--   will be used as the default filter. If that list is empty, the dialog
--   will be unfiltered.
--   
--   <i>Since: 4.10</i>
fileDialogSetDefaultFilter :: (HasCallStack, MonadIO m, IsFileDialog a, IsFileFilter b) => a -> Maybe b -> m ()

-- | Sets the filters that will be offered to the user in the file chooser
--   dialog.
--   
--   <i>Since: 4.10</i>
fileDialogSetFilters :: (HasCallStack, MonadIO m, IsFileDialog a, IsListModel b) => a -> Maybe b -> m ()

-- | Sets the file that will be initially selected in the file chooser
--   dialog.
--   
--   This function is a shortcut for calling both
--   <a>fileDialogSetInitialFolder</a> and <a>fileDialogSetInitialName</a>
--   with the directory and name of <i><tt>file</tt></i>, respectively.
--   
--   <i>Since: 4.10</i>
fileDialogSetInitialFile :: (HasCallStack, MonadIO m, IsFileDialog a, IsFile b) => a -> Maybe b -> m ()

-- | Sets the folder that will be set as the initial folder in the file
--   chooser dialog.
--   
--   <i>Since: 4.10</i>
fileDialogSetInitialFolder :: (HasCallStack, MonadIO m, IsFileDialog a, IsFile b) => a -> Maybe b -> m ()

-- | Sets the filename that will be initially selected.
--   
--   For save dialogs, <i><tt>name</tt></i> will usually be pre-entered
--   into the name field.
--   
--   If a file with this name already exists in the directory set via
--   <a>FileDialog:initialFolder</a>, the dialog will preselect it.
--   
--   <i>Since: 4.10</i>
fileDialogSetInitialName :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> Maybe Text -> m ()

-- | Sets whether the file chooser dialog blocks interaction with the
--   parent window while it is presented.
--   
--   <i>Since: 4.10</i>
fileDialogSetModal :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> Bool -> m ()

-- | Sets the title that will be shown on the file chooser dialog.
--   
--   <i>Since: 4.10</i>
fileDialogSetTitle :: (HasCallStack, MonadIO m, IsFileDialog a) => a -> Text -> m ()

-- | Set the value of the “<tt>accept-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #acceptLabel
--   </pre>
clearFileDialogAcceptLabel :: (MonadIO m, IsFileDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accept-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileDialogAcceptLabel :: (IsFileDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #acceptLabel
--   </pre>
getFileDialogAcceptLabel :: (MonadIO m, IsFileDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #acceptLabel <a>:=</a> value ]
--   </pre>
setFileDialogAcceptLabel :: (MonadIO m, IsFileDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>default-filter</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #defaultFilter
--   </pre>
clearFileDialogDefaultFilter :: (MonadIO m, IsFileDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-filter</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileDialogDefaultFilter :: (IsFileDialog o, MonadIO m, IsFileFilter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #defaultFilter
--   </pre>
getFileDialogDefaultFilter :: (MonadIO m, IsFileDialog o) => o -> m (Maybe FileFilter)

-- | Set the value of the “<tt>default-filter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #defaultFilter <a>:=</a> value ]
--   </pre>
setFileDialogDefaultFilter :: (MonadIO m, IsFileDialog o, IsFileFilter a) => o -> a -> m ()

-- | Set the value of the “<tt>filters</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #filters
--   </pre>
clearFileDialogFilters :: (MonadIO m, IsFileDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>filters</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileDialogFilters :: (IsFileDialog o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>filters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #filters
--   </pre>
getFileDialogFilters :: (MonadIO m, IsFileDialog o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>filters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #filters <a>:=</a> value ]
--   </pre>
setFileDialogFilters :: (MonadIO m, IsFileDialog o, IsListModel a) => o -> a -> m ()

-- | Set the value of the “<tt>initial-file</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #initialFile
--   </pre>
clearFileDialogInitialFile :: (MonadIO m, IsFileDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>initial-file</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileDialogInitialFile :: (IsFileDialog o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>initial-file</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #initialFile
--   </pre>
getFileDialogInitialFile :: (MonadIO m, IsFileDialog o) => o -> m (Maybe File)

-- | Set the value of the “<tt>initial-file</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #initialFile <a>:=</a> value ]
--   </pre>
setFileDialogInitialFile :: (MonadIO m, IsFileDialog o, IsFile a) => o -> a -> m ()

-- | Set the value of the “<tt>initial-folder</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #initialFolder
--   </pre>
clearFileDialogInitialFolder :: (MonadIO m, IsFileDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>initial-folder</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructFileDialogInitialFolder :: (IsFileDialog o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>initial-folder</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #initialFolder
--   </pre>
getFileDialogInitialFolder :: (MonadIO m, IsFileDialog o) => o -> m (Maybe File)

-- | Set the value of the “<tt>initial-folder</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #initialFolder <a>:=</a> value ]
--   </pre>
setFileDialogInitialFolder :: (MonadIO m, IsFileDialog o, IsFile a) => o -> a -> m ()

-- | Set the value of the “<tt>initial-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #initialName
--   </pre>
clearFileDialogInitialName :: (MonadIO m, IsFileDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>initial-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileDialogInitialName :: (IsFileDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>initial-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #initialName
--   </pre>
getFileDialogInitialName :: (MonadIO m, IsFileDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>initial-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #initialName <a>:=</a> value ]
--   </pre>
setFileDialogInitialName :: (MonadIO m, IsFileDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileDialogModal :: (IsFileDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #modal
--   </pre>
getFileDialogModal :: (MonadIO m, IsFileDialog o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #modal <a>:=</a> value ]
--   </pre>
setFileDialogModal :: (MonadIO m, IsFileDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFileDialogTitle :: (IsFileDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileDialog #title
--   </pre>
getFileDialogTitle :: (MonadIO m, IsFileDialog o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileDialog [ #title <a>:=</a> value ]
--   </pre>
setFileDialogTitle :: (MonadIO m, IsFileDialog o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.FileDialog.FileDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FileDialog.FileDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FileDialog.FileDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FileDialog.FileDialog o) => GI.Gtk.Objects.FileDialog.IsFileDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FileDialog.FileDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FileDialog.FileDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FileDialog.FileDialog


-- | <tt>GtkFileChooserWidget</tt> is a widget for choosing files.
--   
--   It exposes the <a>FileChooser</a> interface, and you should use the
--   methods of this interface to interact with the widget.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkFileChooserWidget</tt> supports the following keyboard
--   shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;F10&lt;/kbd&gt; or
--   &lt;kbd&gt;Menu&lt;/kbd&gt; opens the context menu.</li>
--   </ul>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>FileChooserWidget::desktopFolder</a></li>
--   <li><a>FileChooserWidget::downFolder</a></li>
--   <li><a>FileChooserWidget::homeFolder</a></li>
--   <li><a>FileChooserWidget::locationPopup</a></li>
--   <li><a>FileChooserWidget::locationPopupOnPaste</a></li>
--   <li><a>FileChooserWidget::locationTogglePopup</a></li>
--   <li><a>FileChooserWidget::placesShortcut</a></li>
--   <li><a>FileChooserWidget::quickBookmark</a></li>
--   <li><a>FileChooserWidget::recentShortcut</a></li>
--   <li><a>FileChooserWidget::searchShortcut</a></li>
--   <li><a>FileChooserWidget::showHidden</a></li>
--   <li><a>FileChooserWidget::upFolder</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkFileChooserWidget</tt> has a single CSS node with name
--   filechooser.
module GI.Gtk.Objects.FileChooserWidget

-- | Memory-managed wrapper type.
newtype FileChooserWidget
FileChooserWidget :: ManagedPtr FileChooserWidget -> FileChooserWidget

-- | Type class for types which can be safely cast to
--   <a>FileChooserWidget</a>, for instance with
--   <a>toFileChooserWidget</a>.
class (GObject o, IsDescendantOf FileChooserWidget o) => IsFileChooserWidget o

-- | Cast to <a>FileChooserWidget</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFileChooserWidget :: (MonadIO m, IsFileChooserWidget o) => o -> m FileChooserWidget

-- | Creates a new <tt>GtkFileChooserWidget</tt>.
--   
--   This is a file chooser widget that can be embedded in custom windows,
--   and it is the same widget that is used by
--   <tt>GtkFileChooserDialog</tt>.

-- | <i>Deprecated: (Since version 4.10)Direct use of
--   <tt>GtkFileChooserWidget</tt> is deprecated</i>
fileChooserWidgetNew :: (HasCallStack, MonadIO m) => FileChooserAction -> m FileChooserWidget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-mode</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserWidgetSearchMode :: (IsFileChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>search-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserWidget #searchMode
--   </pre>
getFileChooserWidgetSearchMode :: (MonadIO m, IsFileChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>search-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserWidget [ #searchMode <a>:=</a> value ]
--   </pre>
setFileChooserWidgetSearchMode :: (MonadIO m, IsFileChooserWidget o) => o -> Bool -> m ()

-- | Get the value of the “<tt>show-time</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserWidget #showTime
--   </pre>
getFileChooserWidgetShowTime :: (MonadIO m, IsFileChooserWidget o) => o -> m Bool

-- | Get the value of the “<tt>subtitle</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserWidget #subtitle
--   </pre>
getFileChooserWidgetSubtitle :: (MonadIO m, IsFileChooserWidget o) => o -> m (Maybe Text)

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser show the user's Desktop folder
--   in the file list.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;D&lt;/kbd&gt;.
type FileChooserWidgetDesktopFolderCallback = IO ()

-- | Connect a signal handler for the <a>desktopFolder</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #desktopFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetDesktopFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDesktopFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>desktopFolder</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #desktopFolder callback
--   </pre>
onFileChooserWidgetDesktopFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDesktopFolderCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser go to a child of the current
--   folder in the file hierarchy. The subfolder that will be used is
--   displayed in the path bar widget of the file chooser. For example, if
--   the path bar is showing "/foo/bar/baz", with bar currently displayed,
--   then this will cause the file chooser to switch to the "baz"
--   subfolder.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;Down&lt;/kbd&gt;.
type FileChooserWidgetDownFolderCallback = IO ()

-- | Connect a signal handler for the <a>downFolder</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #downFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetDownFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDownFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>downFolder</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #downFolder callback
--   </pre>
onFileChooserWidgetDownFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetDownFolderCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser show the user's home folder in
--   the file list.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;Home&lt;/kbd&gt;.
type FileChooserWidgetHomeFolderCallback = IO ()

-- | Connect a signal handler for the <a>homeFolder</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #homeFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetHomeFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetHomeFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>homeFolder</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #homeFolder callback
--   </pre>
onFileChooserWidgetHomeFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetHomeFolderCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser show a "Location" prompt which
--   the user can use to manually type the name of the file he wishes to
--   select.
--   
--   The default bindings for this signal are
--   &lt;kbd&gt;Control&lt;/kbd&gt;-&lt;kbd&gt;L&lt;/kbd&gt; with a
--   <i><tt>path</tt></i> string of "" (the empty string). It is also bound
--   to &lt;kbd&gt;/&lt;/kbd&gt; with a <i><tt>path</tt></i> string of
--   "<tt>/</tt>" (a slash): this lets you type <tt>/</tt> and immediately
--   type a path name. On Unix systems, this is bound to
--   &lt;kbd&gt;~&lt;/kbd&gt; (tilde) with a <i><tt>path</tt></i> string of
--   "~" itself for access to home directories.
type FileChooserWidgetLocationPopupCallback = Text -> IO ()

-- | Connect a signal handler for the <a>locationPopup</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #locationPopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetLocationPopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationPopup</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #locationPopup callback
--   </pre>
onFileChooserWidgetLocationPopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser show a "Location" prompt when
--   the user pastes into a <tt>GtkFileChooserWidget</tt>.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Control&lt;/kbd&gt;-&lt;kbd&gt;V&lt;/kbd&gt;.
type FileChooserWidgetLocationPopupOnPasteCallback = IO ()

-- | Connect a signal handler for the <a>locationPopupOnPaste</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #locationPopupOnPaste callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetLocationPopupOnPaste :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupOnPasteCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationPopupOnPaste</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #locationPopupOnPaste callback
--   </pre>
onFileChooserWidgetLocationPopupOnPaste :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationPopupOnPasteCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to toggle the visibility of a "Location" prompt which the
--   user can use to manually type the name of the file he wishes to
--   select.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Control&lt;/kbd&gt;-&lt;kbd&gt;L&lt;/kbd&gt;.
type FileChooserWidgetLocationTogglePopupCallback = IO ()

-- | Connect a signal handler for the <a>locationTogglePopup</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #locationTogglePopup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetLocationTogglePopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationTogglePopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>locationTogglePopup</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #locationTogglePopup callback
--   </pre>
onFileChooserWidgetLocationTogglePopup :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetLocationTogglePopupCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to move the focus to the places sidebar.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;P&lt;/kbd&gt;.
type FileChooserWidgetPlacesShortcutCallback = IO ()

-- | Connect a signal handler for the <a>placesShortcut</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #placesShortcut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetPlacesShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetPlacesShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>placesShortcut</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #placesShortcut callback
--   </pre>
onFileChooserWidgetPlacesShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetPlacesShortcutCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser switch to the bookmark specified
--   in the <i><tt>bookmarkIndex</tt></i> parameter. For example, if you
--   have three bookmarks, you can pass 0, 1, 2 to this signal to switch to
--   each of them, respectively.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;1&lt;/kbd&gt;,
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;2&lt;/kbd&gt;, etc. until
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;0&lt;/kbd&gt;. Note that in the
--   default binding, that
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;1&lt;/kbd&gt; is actually
--   defined to switch to the bookmark at index 0, and so on successively.
type FileChooserWidgetQuickBookmarkCallback = Int32 -> IO ()

-- | Connect a signal handler for the <a>quickBookmark</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #quickBookmark callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetQuickBookmark :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetQuickBookmarkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>quickBookmark</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #quickBookmark callback
--   </pre>
onFileChooserWidgetQuickBookmark :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetQuickBookmarkCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser show the Recent location.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;R&lt;/kbd&gt;.
type FileChooserWidgetRecentShortcutCallback = IO ()

-- | Connect a signal handler for the <a>recentShortcut</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #recentShortcut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetRecentShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetRecentShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>recentShortcut</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #recentShortcut callback
--   </pre>
onFileChooserWidgetRecentShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetRecentShortcutCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser show the search entry.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;S&lt;/kbd&gt;.
type FileChooserWidgetSearchShortcutCallback = IO ()

-- | Connect a signal handler for the <a>searchShortcut</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #searchShortcut callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetSearchShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetSearchShortcutCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>searchShortcut</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #searchShortcut callback
--   </pre>
onFileChooserWidgetSearchShortcut :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetSearchShortcutCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser display hidden files.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Control&lt;/kbd&gt;-&lt;kbd&gt;H&lt;/kbd&gt;.
type FileChooserWidgetShowHiddenCallback = IO ()

-- | Connect a signal handler for the <a>showHidden</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #showHidden callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetShowHidden :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetShowHiddenCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>showHidden</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #showHidden callback
--   </pre>
onFileChooserWidgetShowHidden :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetShowHiddenCallback) -> m SignalHandlerId

-- | Emitted when the user asks for it.
--   
--   This is a <a>keybinding signal</a>.
--   
--   This is used to make the file chooser go to the parent of the current
--   folder in the file hierarchy.
--   
--   The default binding for this signal is
--   &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;Up&lt;/kbd&gt;.
type FileChooserWidgetUpFolderCallback = IO ()

-- | Connect a signal handler for the <a>upFolder</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> fileChooserWidget #upFolder callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFileChooserWidgetUpFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetUpFolderCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>upFolder</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> fileChooserWidget #upFolder callback
--   </pre>
onFileChooserWidgetUpFolder :: (IsFileChooserWidget a, MonadIO m) => a -> ((?self :: a) => FileChooserWidgetUpFolderCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.FileChooserWidget.FileChooserWidget
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FileChooserWidget.FileChooserWidget
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FileChooserWidget.FileChooserWidget
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FileChooserWidget.FileChooserWidget o) => GI.Gtk.Objects.FileChooserWidget.IsFileChooserWidget o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FileChooserWidget.FileChooserWidget)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FileChooserWidget.FileChooserWidget
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FileChooserWidget.FileChooserWidget


-- | <tt>GtkFileChooserNative</tt> is an abstraction of a dialog suitable
--   for use with “File Open” or “File Save as” commands.
--   
--   By default, this just uses a <tt>GtkFileChooserDialog</tt> to
--   implement the actual dialog. However, on some platforms, such as
--   Windows and macOS, the native platform file chooser is used instead.
--   When the application is running in a sandboxed environment without
--   direct filesystem access (such as Flatpak),
--   <tt>GtkFileChooserNative</tt> may call the proper APIs (portals) to
--   let the user choose a file and make it available to the application.
--   
--   While the API of <tt>GtkFileChooserNative</tt> closely mirrors
--   <tt>GtkFileChooserDialog</tt>, the main difference is that there is no
--   access to any <tt>GtkWindow</tt> or <tt>GtkWidget</tt> for the dialog.
--   This is required, as there may not be one in the case of a platform
--   native dialog.
--   
--   Showing, hiding and running the dialog is handled by the
--   <a>NativeDialog</a> functions.
--   
--   Note that unlike <tt>GtkFileChooserDialog</tt>,
--   <tt>GtkFileChooserNative</tt> objects are not toplevel widgets, and
--   GTK does not keep them alive. It is your responsibility to keep a
--   reference until you are done with the object.
--   
--   <h2>Typical usage</h2>
--   
--   In the simplest of cases, you can the following code to use
--   <tt>GtkFileChooserNative</tt> to select a file for opening:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   on_response (GtkNativeDialog *native,
--                int              response)
--   {
--     if (response == GTK_RESPONSE_ACCEPT)
--       {
--         GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
--         GFile *file = gtk_file_chooser_get_file (chooser);
--   
--         open_file (file);
--   
--         g_object_unref (file);
--       }
--   
--     g_object_unref (native);
--   }
--   
--     // ...
--     GtkFileChooserNative *native;
--     GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
--   
--     native = gtk_file_chooser_native_new ("Open File",
--                                           parent_window,
--                                           action,
--                                           "_Open",
--                                           "_Cancel");
--   
--     g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
--     gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
--   </pre>
--   
--   To use a <tt>GtkFileChooserNative</tt> for saving, you can use this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   on_response (GtkNativeDialog *native,
--                int              response)
--   {
--     if (response == GTK_RESPONSE_ACCEPT)
--       {
--         GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
--         GFile *file = gtk_file_chooser_get_file (chooser);
--   
--         save_to_file (file);
--   
--         g_object_unref (file);
--       }
--   
--     g_object_unref (native);
--   }
--   
--     // ...
--     GtkFileChooserNative *native;
--     GtkFileChooser *chooser;
--     GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
--   
--     native = gtk_file_chooser_native_new ("Save File",
--                                           parent_window,
--                                           action,
--                                           "_Save",
--                                           "_Cancel");
--     chooser = GTK_FILE_CHOOSER (native);
--   
--     if (user_edited_a_new_document)
--       gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
--     else
--       gtk_file_chooser_set_file (chooser, existing_file, NULL);
--   
--     g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
--     gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
--   </pre>
--   
--   For more information on how to best set up a file dialog, see the
--   <a>FileChooserDialog</a> documentation.
--   
--   <h2>Response Codes</h2>
--   
--   <tt>GtkFileChooserNative</tt> inherits from <a>NativeDialog</a>, which
--   means it will return <a>ResponseTypeAccept</a> if the user accepted,
--   and <a>ResponseTypeCancel</a> if he pressed cancel. It can also return
--   <a>ResponseTypeDeleteEvent</a> if the window was unexpectedly closed.
--   
--   <h2>Differences from <tt>GtkFileChooserDialog</tt></h2>
--   
--   There are a few things in the <a>FileChooser</a> interface that are
--   not possible to use with <tt>GtkFileChooserNative</tt>, as such use
--   would prohibit the use of a native dialog.
--   
--   No operations that change the dialog work while the dialog is visible.
--   Set all the properties that are required before showing the dialog.
--   
--   <h2>Win32 details</h2>
--   
--   On windows the <tt>IFileDialog</tt> implementation (added in Windows
--   Vista) is used. It supports many of the features that
--   <tt>GtkFileChooser</tt> has, but there are some things it does not
--   handle:
--   
--   <ul>
--   <li>Any <a>FileFilter</a> added using a mimetype</li>
--   </ul>
--   
--   If any of these features are used the regular
--   <tt>GtkFileChooserDialog</tt> will be used in place of the native one.
--   
--   <h2>Portal details</h2>
--   
--   When the <tt>org.freedesktop.portal.FileChooser</tt> portal is
--   available on the session bus, it is used to bring up an out-of-process
--   file chooser. Depending on the kind of session the application is
--   running in, this may or may not be a GTK file chooser.
--   
--   <h2>macOS details</h2>
--   
--   On macOS the <tt>NSSavePanel</tt> and <tt>NSOpenPanel</tt> classes are
--   used to provide native file chooser dialogs. Some features provided by
--   <tt>GtkFileChooser</tt> are not supported:
--   
--   <ul>
--   <li>Shortcut folders.</li>
--   </ul>
module GI.Gtk.Objects.FileChooserNative

-- | Memory-managed wrapper type.
newtype FileChooserNative
FileChooserNative :: ManagedPtr FileChooserNative -> FileChooserNative

-- | Type class for types which can be safely cast to
--   <a>FileChooserNative</a>, for instance with
--   <a>toFileChooserNative</a>.
class (GObject o, IsDescendantOf FileChooserNative o) => IsFileChooserNative o

-- | Cast to <a>FileChooserNative</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFileChooserNative :: (MonadIO m, IsFileChooserNative o) => o -> m FileChooserNative

-- | Retrieves the custom label text for the accept button.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserNativeGetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> m (Maybe Text)

-- | Retrieves the custom label text for the cancel button.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserNativeGetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> m (Maybe Text)

-- | Creates a new <tt>GtkFileChooserNative</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserNativeNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> FileChooserAction -> Maybe Text -> Maybe Text -> m FileChooserNative

-- | Sets the custom label text for the accept button.
--   
--   If characters in <i><tt>label</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use “__” (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic.
--   
--   Pressing Alt and that key should activate the button.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserNativeSetAcceptLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

-- | Sets the custom label text for the cancel button.
--   
--   If characters in <i><tt>label</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use “__” (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic.
--   
--   Pressing Alt and that key should activate the button.

-- | <i>Deprecated: (Since version 4.10)Use <a>FileDialog</a> instead</i>
fileChooserNativeSetCancelLabel :: (HasCallStack, MonadIO m, IsFileChooserNative a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>accept-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #acceptLabel
--   </pre>
clearFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accept-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserNativeAcceptLabel :: (IsFileChooserNative o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserNative #acceptLabel
--   </pre>
getFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>accept-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserNative [ #acceptLabel <a>:=</a> value ]
--   </pre>
setFileChooserNativeAcceptLabel :: (MonadIO m, IsFileChooserNative o) => o -> Text -> m ()

-- | Set the value of the “<tt>cancel-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cancelLabel
--   </pre>
clearFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cancel-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFileChooserNativeCancelLabel :: (IsFileChooserNative o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>cancel-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fileChooserNative #cancelLabel
--   </pre>
getFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>cancel-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fileChooserNative [ #cancelLabel <a>:=</a> value ]
--   </pre>
setFileChooserNativeCancelLabel :: (MonadIO m, IsFileChooserNative o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.FileChooserNative.FileChooserNative
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FileChooserNative.FileChooserNative
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FileChooserNative.FileChooserNative
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FileChooserNative.FileChooserNative o) => GI.Gtk.Objects.FileChooserNative.IsFileChooserNative o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FileChooserNative.FileChooserNative)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FileChooserNative.FileChooserNative
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FileChooserNative.FileChooserNative


-- | <tt>GtkFileChooserDialog</tt> is a dialog suitable for use with “File
--   Open” or “File Save” commands.
--   
--   
--   This widget works by putting a <a>FileChooserWidget</a> inside a
--   <a>Dialog</a>. It exposes the <a>FileChooser</a> interface, so you can
--   use all of the <a>FileChooser</a> functions on the file chooser dialog
--   as well as those for <a>Dialog</a>.
--   
--   Note that <tt>GtkFileChooserDialog</tt> does not have any methods of
--   its own. Instead, you should use the functions that work on a
--   <a>FileChooser</a>.
--   
--   If you want to integrate well with the platform you should use the
--   <a>FileChooserNative</a> API, which will use a platform-specific
--   dialog if available and fall back to <tt>GtkFileChooserDialog</tt>
--   otherwise.
--   
--   <h2>Typical usage</h2>
--   
--   In the simplest of cases, you can the following code to use
--   <tt>GtkFileChooserDialog</tt> to select a file for opening:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   on_open_response (GtkDialog *dialog,
--                     int        response)
--   {
--     if (response == GTK_RESPONSE_ACCEPT)
--       {
--         GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
--   
--         g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
--   
--         open_file (file);
--       }
--   
--     gtk_window_destroy (GTK_WINDOW (dialog));
--   }
--   
--     // ...
--     GtkWidget *dialog;
--     GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
--   
--     dialog = gtk_file_chooser_dialog_new ("Open File",
--                                           parent_window,
--                                           action,
--                                           _("_Cancel"),
--                                           GTK_RESPONSE_CANCEL,
--                                           _("_Open"),
--                                           GTK_RESPONSE_ACCEPT,
--                                           NULL);
--   
--     gtk_window_present (GTK_WINDOW (dialog));
--   
--     g_signal_connect (dialog, "response",
--                       G_CALLBACK (on_open_response),
--                       NULL);
--   </pre>
--   
--   To use a dialog for saving, you can use this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   on_save_response (GtkDialog *dialog,
--                     int        response)
--   {
--     if (response == GTK_RESPONSE_ACCEPT)
--       {
--         GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
--   
--         g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
--   
--         save_to_file (file);
--       }
--   
--     gtk_window_destroy (GTK_WINDOW (dialog));
--   }
--   
--     // ...
--     GtkWidget *dialog;
--     GtkFileChooser *chooser;
--     GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
--   
--     dialog = gtk_file_chooser_dialog_new ("Save File",
--                                           parent_window,
--                                           action,
--                                           _("_Cancel"),
--                                           GTK_RESPONSE_CANCEL,
--                                           _("_Save"),
--                                           GTK_RESPONSE_ACCEPT,
--                                           NULL);
--     chooser = GTK_FILE_CHOOSER (dialog);
--   
--     if (user_edited_a_new_document)
--       gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
--     else
--       gtk_file_chooser_set_file (chooser, existing_filename);
--   
--     gtk_window_present (GTK_WINDOW (dialog));
--   
--     g_signal_connect (dialog, "response",
--                       G_CALLBACK (on_save_response),
--                       NULL);
--   </pre>
--   
--   <h2>Setting up a file chooser dialog</h2>
--   
--   There are various cases in which you may need to use a
--   <tt>GtkFileChooserDialog</tt>:
--   
--   <ul>
--   <li>To select a file for opening, use
--   <a>FileChooserActionOpen</a>.</li>
--   <li>To save a file for the first time, use
--   <a>FileChooserActionSave</a>, and suggest a name such as “Untitled”
--   with <a>fileChooserSetCurrentName</a>.</li>
--   <li>To save a file under a different name, use
--   <a>FileChooserActionSave</a>, and set the existing file with
--   <a>fileChooserSetFile</a>.</li>
--   <li>To choose a folder instead of a file, use
--   <a>FileChooserActionSelectFolder</a>.</li>
--   </ul>
--   
--   In general, you should only cause the file chooser to show a specific
--   folder when it is appropriate to use <a>fileChooserSetFile</a>, i.e.
--   when you are doing a “Save As” command and you already have a file
--   saved somewhere.
--   
--   <h2>Response Codes</h2>
--   
--   <tt>GtkFileChooserDialog</tt> inherits from <a>Dialog</a>, so buttons
--   that go in its action area have response codes such as
--   <a>ResponseTypeAccept</a> and <a>ResponseTypeCancel</a>. For example,
--   you could call <a>FileChooserDialog</a>.<tt><i>new</i></tt>() as
--   follows:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *dialog;
--   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
--   
--   dialog = gtk_file_chooser_dialog_new ("Open File",
--                                         parent_window,
--                                         action,
--                                         _("_Cancel"),
--                                         GTK_RESPONSE_CANCEL,
--                                         _("_Open"),
--                                         GTK_RESPONSE_ACCEPT,
--                                         NULL);
--   </pre>
--   
--   This will create buttons for “Cancel” and “Open” that use predefined
--   response identifiers from <a>ResponseType</a>. For most dialog boxes
--   you can use your own custom response codes rather than the ones in
--   <a>ResponseType</a>, but <tt>GtkFileChooserDialog</tt> assumes that
--   its “accept”-type action, e.g. an “Open” or “Save” button, will have
--   one of the following response codes:
--   
--   <ul>
--   <li><a>ResponseTypeAccept</a></li>
--   <li><a>ResponseTypeOk</a></li>
--   <li><a>ResponseTypeYes</a></li>
--   <li><a>ResponseTypeApply</a></li>
--   </ul>
--   
--   This is because <tt>GtkFileChooserDialog</tt> must intercept responses
--   and switch to folders if appropriate, rather than letting the dialog
--   terminate — the implementation uses these known response codes to know
--   which responses can be blocked if appropriate.
--   
--   To summarize, make sure you use a predefined response code when you
--   use <tt>GtkFileChooserDialog</tt> to ensure proper operation.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkFileChooserDialog</tt> has a single CSS node with the name
--   <tt>window</tt> and style class <tt>.filechooser</tt>.
module GI.Gtk.Objects.FileChooserDialog

-- | Memory-managed wrapper type.
newtype FileChooserDialog
FileChooserDialog :: ManagedPtr FileChooserDialog -> FileChooserDialog

-- | Type class for types which can be safely cast to
--   <a>FileChooserDialog</a>, for instance with
--   <a>toFileChooserDialog</a>.
class (GObject o, IsDescendantOf FileChooserDialog o) => IsFileChooserDialog o

-- | Cast to <a>FileChooserDialog</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toFileChooserDialog :: (MonadIO m, IsFileChooserDialog o) => o -> m FileChooserDialog
instance GHC.Classes.Eq GI.Gtk.Objects.FileChooserDialog.FileChooserDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.FileChooserDialog.FileChooserDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.FileChooserDialog.FileChooserDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.FileChooserDialog.FileChooserDialog o) => GI.Gtk.Objects.FileChooserDialog.IsFileChooserDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.FileChooserDialog.FileChooserDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.FileChooserDialog.FileChooserDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.FileChooserDialog.FileChooserDialog


-- | Provides a way to describe references to values.
--   
--   An important aspect of expressions is that the value can be obtained
--   from a source that is several steps away. For example, an expression
--   may describe ‘the value of property A of <tt>object1</tt>, which is
--   itself the value of a property of <tt>object2</tt>’. And
--   <tt>object1</tt> may not even exist yet at the time that the
--   expression is created. This is contrast to <tt>GObject</tt> property
--   bindings, which can only create direct connections between the
--   properties of two objects that must both exist for the duration of the
--   binding.
--   
--   An expression needs to be "evaluated" to obtain the value that it
--   currently refers to. An evaluation always happens in the context of a
--   current object called <tt>this</tt> (it mirrors the behavior of
--   object-oriented languages), which may or may not influence the result
--   of the evaluation. Use <a>expressionEvaluate</a> for evaluating an
--   expression.
--   
--   Various methods for defining expressions exist, from simple constants
--   via <a>ConstantExpression</a>.<tt><i>new</i></tt>() to looking up
--   properties in a <tt>GObject</tt> (even recursively) via
--   <a>propertyExpressionNew</a> or providing custom functions to
--   transform and combine expressions via <a>closureExpressionNew</a>.
--   
--   Here is an example of a complex expression:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   color_expr = gtk_property_expression_new (GTK_TYPE_LIST_ITEM,
--                                             NULL, "item");
--   expression = gtk_property_expression_new (GTK_TYPE_COLOR,
--                                             color_expr, "name");
--   </pre>
--   
--   when evaluated with <tt>this</tt> being a <tt>GtkListItem</tt>, it
--   will obtain the "item" property from the <tt>GtkListItem</tt>, and
--   then obtain the "name" property from the resulting object (which is
--   assumed to be of type <tt>GTK_TYPE_COLOR</tt>).
--   
--   A more concise way to describe this would be
--   
--   <pre>
--   this-&gt;item-&gt;name
--   </pre>
--   
--   The most likely place where you will encounter expressions is in the
--   context of list models and list widgets using them. For example,
--   <tt>GtkDropDown</tt> is evaluating a <tt>GtkExpression</tt> to obtain
--   strings from the items in its model that it can then use to match
--   against the contents of its search entry. <tt>GtkStringFilter</tt> is
--   using a <tt>GtkExpression</tt> for similar reasons.
--   
--   By default, expressions are not paying attention to changes and
--   evaluation is just a snapshot of the current state at a given time. To
--   get informed about changes, an expression needs to be "watched" via a
--   <a>ExpressionWatch</a>, which will cause a callback to be called
--   whenever the value of the expression may have changed;
--   <a>expressionWatch</a> starts watching an expression, and
--   <a>expressionWatchUnwatch</a> stops.
--   
--   Watches can be created for automatically updating the property of an
--   object, similar to GObject's <tt>GBinding</tt> mechanism, by using
--   <a>expressionBind</a>.
--   
--   <h2>GtkExpression in GObject properties</h2>
--   
--   In order to use a <tt>GtkExpression</tt> as a <tt>GObject</tt>
--   property, you must use the <a>paramSpecExpression</a> when creating a
--   <tt>GParamSpec</tt> to install in the <tt>GObject</tt> class being
--   defined; for instance:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   obj_props[PROP_EXPRESSION] =
--     gtk_param_spec_expression ("expression",
--                                "Expression",
--                                "The expression used by the widget",
--                                G_PARAM_READWRITE |
--                                G_PARAM_STATIC_STRINGS |
--                                G_PARAM_EXPLICIT_NOTIFY);
--   </pre>
--   
--   When implementing the <tt>GObjectClass.set_property</tt> and
--   <tt>GObjectClass.get_property</tt> virtual functions, you must use
--   <a>valueGetExpression</a>, to retrieve the stored
--   <tt>GtkExpression</tt> from the <tt>GValue</tt> container, and
--   <a>valueSetExpression</a>, to store the <tt>GtkExpression</tt> into
--   the <tt>GValue</tt>; for instance:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // in set_property()...
--   case PROP_EXPRESSION:
--     foo_widget_set_expression (foo, gtk_value_get_expression (value));
--     break;
--   
--   // in get_property()...
--   case PROP_EXPRESSION:
--     gtk_value_set_expression (value, foo-&gt;expression);
--     break;
--   </pre>
--   
--   <h2>GtkExpression in .ui files</h2>
--   
--   <tt>GtkBuilder</tt> has support for creating expressions. The syntax
--   here can be used where a <tt>GtkExpression</tt> object is needed like
--   in a <tt>&lt;property&gt;</tt> tag for an expression property, or in a
--   <tt>&lt;binding name="property"&gt;</tt> tag to bind a property to an
--   expression.
--   
--   To create a property expression, use the <tt>&lt;lookup&gt;</tt>
--   element. It can have a <tt>type</tt> attribute to specify the object
--   type, and a <tt>name</tt> attribute to specify the property to look
--   up. The content of <tt>&lt;lookup&gt;</tt> can either be a string that
--   specifies the name of the object to use, an element specifying an
--   expression to provide an object, or empty to use the <tt>this</tt>
--   object.
--   
--   Example:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;lookup name='search'&gt;string_filter&lt;/lookup&gt;
--   </pre>
--   
--   Since the <tt>&lt;lookup&gt;</tt> element creates an expression and
--   its element content can itself be an expression, this means that
--   <tt>&lt;lookup&gt;</tt> tags can also be nested. This is a common
--   idiom when dealing with <tt>GtkListItem</tt>s. See
--   <a>BuilderListItemFactory</a> for an example of this technique.
--   
--   To create a constant expression, use the <tt>&lt;constant&gt;</tt>
--   element. If the type attribute is specified, the element content is
--   interpreted as a value of that type, and the initial attribute can be
--   specified to get the initial value for that type. Otherwise, it is
--   assumed to be an object. For instance:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;constant&gt;string_filter&lt;/constant&gt;
--   &lt;constant type='gchararray'&gt;Hello, world&lt;/constant&gt;
--   &lt;constant type='gchararray' initial='true' /&gt; &lt;!-- NULL --&gt;
--   </pre>
--   
--   String (<tt>type='gchararray'</tt>) constants can be marked for
--   translation with the <tt>translatable=</tt> attribute, and will then
--   be looked up in the <a>Builder:translationDomain</a> when the
--   expression is constructed.
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;constant type='gchararray' translatable='yes'&gt;I'm translatable!&lt;/constant&gt;
--   </pre>
--   
--   As with other translatable strings in
--   [type<i><tt>gtk</tt></i>.Builder], constants can also have a context
--   and/or translation comment:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;constant type='gchararray'
--             translatable='yes'
--             context='example'
--             comments='A sample string'&gt;I'm translatable!&lt;/constant&gt;
--   </pre>
--   
--   To create a closure expression, use the <tt>&lt;closure&gt;</tt>
--   element. The <tt>function</tt> attribute specifies what function to
--   use for the closure, and the <tt>type</tt> attribute specifies its
--   return type. The content of the element contains the expressions for
--   the parameters. For instance:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;closure type='gchararray' function='combine_args_somehow'&gt;
--     &lt;constant type='gchararray'&gt;File size:&lt;/constant&gt;
--     &lt;lookup type='GFile' name='size'&gt;myfile&lt;/lookup&gt;
--   &lt;/closure&gt;
--   </pre>
--   
--   If an expression can fail, a <tt>&lt;try&gt;</tt> element can be used
--   to provide fallbacks. The expressions are tried from top to bottom
--   until one of them succeeds. If none of the expressions succeed, the
--   expression fails as normal:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;try&gt;
--     &lt;lookup type='GtkWindow' name='title'&gt;
--       &lt;lookup type='GtkLabel' name='root'&gt;&lt;/lookup&gt;
--     &lt;/lookup&gt;
--     &lt;constant type='gchararray'&gt;Hello World&lt;/constant&gt;
--   &lt;/try&gt;
--   </pre>
--   
--   To create a property binding, use the <tt>&lt;binding&gt;</tt> element
--   in place of where a <tt>&lt;property&gt;</tt> tag would ordinarily be
--   used. The <tt>name</tt> and <tt>object</tt> attributes are supported.
--   The <tt>name</tt> attribute is required, and pertains to the
--   applicable property name. The <tt>object</tt> attribute is optional.
--   If provided, it will use the specified object as the <tt>this</tt>
--   object when the expression is evaluated. Here is an example in which
--   the <tt>label</tt> property of a <tt>GtkLabel</tt> is bound to the
--   <tt>string</tt> property of another arbitrary object:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class='GtkLabel'&gt;
--     &lt;binding name='label'&gt;
--       &lt;lookup name='string'&gt;some_other_object&lt;/lookup&gt;
--     &lt;/binding&gt;
--   &lt;/object&gt;
--   </pre>
module GI.Gtk.Objects.Expression

-- | Memory-managed wrapper type.
newtype Expression
Expression :: ManagedPtr Expression -> Expression

-- | Type class for types which can be safely cast to <a>Expression</a>,
--   for instance with <a>toExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf Expression o) => IsExpression o

-- | Cast to <a>Expression</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toExpression :: (MonadIO m, IsExpression o) => o -> m Expression

-- | Bind <tt>target</tt>'s property named <tt>property</tt> to
--   <tt>self</tt>.
--   
--   The value that <tt>self</tt> evaluates to is set via
--   <tt>g_object_set()</tt> on <tt>target</tt>. This is repeated whenever
--   <tt>self</tt> changes to ensure that the object's property stays
--   synchronized with <tt>self</tt>.
--   
--   If <tt>self</tt>'s evaluation fails, <tt>target</tt>'s
--   <tt>property</tt> is not updated. Use a <a>TryExpression</a> to
--   provide a fallback for this case.
--   
--   Note that this function takes ownership of <tt>self</tt>. If you want
--   to keep it around, you should <a>expressionRef</a> it beforehand.
expressionBind :: (HasCallStack, MonadIO m, IsExpression a, IsObject b, IsObject c) => a -> b -> Text -> Maybe c -> m ExpressionWatch

-- | Evaluates the given expression and on success stores the result in
--   <i><tt>value</tt></i>.
--   
--   The <tt>GType</tt> of <tt>value</tt> will be the type given by
--   <a>expressionGetValueType</a>.
--   
--   It is possible that expressions cannot be evaluated - for example when
--   the expression references objects that have been destroyed or set to
--   <tt>NULL</tt>. In that case <tt>value</tt> will remain empty and
--   <tt>FALSE</tt> will be returned.
expressionEvaluate :: (HasCallStack, MonadIO m, IsExpression a, IsObject b) => a -> Maybe b -> GValue -> m Bool

-- | Gets the <tt>GType</tt> that this expression evaluates to.
--   
--   This type is constant and will not change over the lifetime of this
--   expression.
expressionGetValueType :: (HasCallStack, MonadIO m, IsExpression a) => a -> m GType

-- | Checks if the expression is static.
--   
--   A static expression will never change its result when
--   <a>expressionEvaluate</a> is called on it with the same arguments.
--   
--   That means a call to <a>expressionWatch</a> is not necessary because
--   it will never trigger a notify.
expressionIsStatic :: (HasCallStack, MonadIO m, IsExpression a) => a -> m Bool

-- | Acquires a reference on the given <tt>GtkExpression</tt>.
expressionRef :: (HasCallStack, MonadIO m, IsExpression a) => a -> m Expression

-- | Releases a reference on the given <tt>GtkExpression</tt>.
--   
--   If the reference was the last, the resources associated to the
--   <tt>self</tt> are freed.
expressionUnref :: (HasCallStack, MonadIO m, IsExpression a) => a -> m ()

-- | Watch the given <tt>expression</tt> for changes.
--   
--   The <i><tt>notify</tt></i> function will be called whenever the
--   evaluation of <tt>self</tt> may have changed.
--   
--   GTK cannot guarantee that the evaluation did indeed change when the
--   <i><tt>notify</tt></i> gets invoked, but it guarantees the opposite:
--   When it did in fact change, the <i><tt>notify</tt></i> will be
--   invoked.
expressionWatch :: (HasCallStack, MonadIO m, IsExpression a, IsObject b) => a -> Maybe b -> ExpressionNotify -> m ExpressionWatch
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.Expression.Expression
instance GHC.Classes.Eq GI.Gtk.Objects.Expression.Expression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Expression.Expression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Expression.Expression o) => GI.Gtk.Objects.Expression.IsExpression o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Expression.Expression)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Expression.Expression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Expression.Expression


-- | Allows the user to reveal or conceal a child widget.
--   
--   &lt;picture&gt; &lt;source srcset="expander-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkExpander" src="expander.png"&gt; &lt;/picture&gt;
--   
--   This is similar to the triangles used in a <tt>GtkTreeView</tt>.
--   
--   Normally you use an expander as you would use a frame; you create the
--   child widget and use <a>expanderSetChild</a> to add it to the
--   expander. When the expander is toggled, it will take care of showing
--   and hiding the child automatically.
--   
--   <h1>Special Usage</h1>
--   
--   There are situations in which you may prefer to show and hide the
--   expanded widget yourself, such as when you want to actually create the
--   widget at expansion time. In this case, create a <tt>GtkExpander</tt>
--   but do not add a child to it. The expander widget has an
--   <a>Expander:expanded</a> property which can be used to monitor its
--   expansion state. You should watch this property with a signal
--   connection as follows:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   expander_callback (GObject    *object,
--                      GParamSpec *param_spec,
--                      gpointer    user_data)
--   {
--     GtkExpander *expander;
--   
--     expander = GTK_EXPANDER (object);
--   
--     if (gtk_expander_get_expanded (expander))
--       {
--         // Show or create widgets
--       }
--     else
--       {
--         // Hide or destroy widgets
--       }
--   }
--   
--   static void
--   create_expander (void)
--   {
--     GtkWidget *expander = gtk_expander_new_with_mnemonic ("_More Options");
--     g_signal_connect (expander, "notify::expanded",
--                       G_CALLBACK (expander_callback), NULL);
--   
--     // ...
--   }
--   </pre>
--   
--   <h1>GtkExpander as GtkBuildable</h1>
--   
--   An example of a UI definition fragment with GtkExpander:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkExpander"&gt;
--     &lt;property name="label-widget"&gt;
--       &lt;object class="GtkLabel" id="expander-label"/&gt;
--     &lt;/property&gt;
--     &lt;property name="child"&gt;
--       &lt;object class="GtkEntry" id="expander-content"/&gt;
--     &lt;/property&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   expander-widget
--   ╰── box
--       ├── title
--       │   ├── expander
--       │   ╰── &lt;label widget&gt;
--       ╰── &lt;child&gt;
--   </pre>
--   
--   <tt>GtkExpander</tt> has a main node <tt>expander-widget</tt>, and
--   subnode <tt>box</tt> containing the title and child widget. The box
--   subnode <tt>title</tt> contains node <tt>expander</tt>, i.e. the
--   expand/collapse arrow; then the label widget if any. The arrow of an
--   expander that is showing its child gets the <tt>:checked</tt>
--   pseudoclass set on it.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkExpander</tt> uses the <a>AccessibleRoleButton</a> role.
module GI.Gtk.Objects.Expander

-- | Memory-managed wrapper type.
newtype Expander
Expander :: ManagedPtr Expander -> Expander

-- | Type class for types which can be safely cast to <a>Expander</a>, for
--   instance with <a>toExpander</a>.
class (GObject o, IsDescendantOf Expander o) => IsExpander o

-- | Cast to <a>Expander</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toExpander :: (MonadIO m, IsExpander o) => o -> m Expander

-- | Gets the child widget of <i><tt>expander</tt></i>.
expanderGetChild :: (HasCallStack, MonadIO m, IsExpander a) => a -> m (Maybe Widget)

-- | Queries a <tt>GtkExpander</tt> and returns its current state.
--   
--   Returns <a>True</a> if the child widget is revealed.
expanderGetExpanded :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Fetches the text from a label widget.
--   
--   This is including any embedded underlines indicating mnemonics and
--   Pango markup, as set by <a>expanderSetLabel</a>. If the label text has
--   not been set the return value will be <a>Nothing</a>. This will be the
--   case if you create an empty button with <a>buttonNew</a> to use as a
--   container.
expanderGetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> m (Maybe Text)

-- | Retrieves the label widget for the frame.
expanderGetLabelWidget :: (HasCallStack, MonadIO m, IsExpander a) => a -> m (Maybe Widget)

-- | Returns whether the expander will resize the toplevel widget
--   containing the expander upon resizing and collapsing.
expanderGetResizeToplevel :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Returns whether the label’s text is interpreted as Pango markup.
expanderGetUseMarkup :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Returns whether an underline in the text indicates a mnemonic.
expanderGetUseUnderline :: (HasCallStack, MonadIO m, IsExpander a) => a -> m Bool

-- | Creates a new expander using <i><tt>label</tt></i> as the text of the
--   label.
expanderNew :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

-- | Creates a new expander using <i><tt>label</tt></i> as the text of the
--   label.
--   
--   If characters in <i><tt>label</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use “__” (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic.
--   
--   Pressing Alt and that key activates the button.
expanderNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m Expander

-- | Sets the child widget of <i><tt>expander</tt></i>.
expanderSetChild :: (HasCallStack, MonadIO m, IsExpander a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the state of the expander.
--   
--   Set to <a>True</a>, if you want the child widget to be revealed, and
--   <a>False</a> if you want the child widget to be hidden.
expanderSetExpanded :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Sets the text of the label of the expander to <i><tt>label</tt></i>.
--   
--   This will also clear any previously set labels.
expanderSetLabel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Maybe Text -> m ()

-- | Set the label widget for the expander.
--   
--   This is the widget that will appear embedded alongside the expander
--   arrow.
expanderSetLabelWidget :: (HasCallStack, MonadIO m, IsExpander a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the expander will resize the toplevel widget containing
--   the expander upon resizing and collapsing.
expanderSetResizeToplevel :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Sets whether the text of the label contains Pango markup.
expanderSetUseMarkup :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | If true, an underline in the text indicates a mnemonic.
expanderSetUseUnderline :: (HasCallStack, MonadIO m, IsExpander a) => a -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearExpanderChild :: (MonadIO m, IsExpander o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructExpanderChild :: (IsExpander o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #child
--   </pre>
getExpanderChild :: (MonadIO m, IsExpander o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #child <a>:=</a> value ]
--   </pre>
setExpanderChild :: (MonadIO m, IsExpander o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expanded</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructExpanderExpanded :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #expanded
--   </pre>
getExpanderExpanded :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #expanded <a>:=</a> value ]
--   </pre>
setExpanderExpanded :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Set the value of the “<tt>label</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearExpanderLabel :: (MonadIO m, IsExpander o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructExpanderLabel :: (IsExpander o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #label
--   </pre>
getExpanderLabel :: (MonadIO m, IsExpander o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #label <a>:=</a> value ]
--   </pre>
setExpanderLabel :: (MonadIO m, IsExpander o) => o -> Text -> m ()

-- | Set the value of the “<tt>label-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #labelWidget
--   </pre>
clearExpanderLabelWidget :: (MonadIO m, IsExpander o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructExpanderLabelWidget :: (IsExpander o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #labelWidget
--   </pre>
getExpanderLabelWidget :: (MonadIO m, IsExpander o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>label-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #labelWidget <a>:=</a> value ]
--   </pre>
setExpanderLabelWidget :: (MonadIO m, IsExpander o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resize-toplevel</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructExpanderResizeToplevel :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resize-toplevel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #resizeToplevel
--   </pre>
getExpanderResizeToplevel :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>resize-toplevel</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #resizeToplevel <a>:=</a> value ]
--   </pre>
setExpanderResizeToplevel :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-markup</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructExpanderUseMarkup :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #useMarkup
--   </pre>
getExpanderUseMarkup :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>use-markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #useMarkup <a>:=</a> value ]
--   </pre>
setExpanderUseMarkup :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructExpanderUseUnderline :: (IsExpander o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> expander #useUnderline
--   </pre>
getExpanderUseUnderline :: (MonadIO m, IsExpander o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> expander [ #useUnderline <a>:=</a> value ]
--   </pre>
setExpanderUseUnderline :: (MonadIO m, IsExpander o) => o -> Bool -> m ()

-- | Activates the <tt>GtkExpander</tt>.
type ExpanderActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> expander #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterExpanderActivate :: (IsExpander a, MonadIO m) => a -> ((?self :: a) => ExpanderActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> expander #activate callback
--   </pre>
onExpanderActivate :: (IsExpander a, MonadIO m) => a -> ((?self :: a) => ExpanderActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Expander.Expander
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Expander.Expander
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Expander.Expander
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Expander.Expander o) => GI.Gtk.Objects.Expander.IsExpander o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Expander.Expander)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Expander.Expander
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Expander.Expander


-- | Handles scroll events.
--   
--   It is capable of handling both discrete and continuous scroll events
--   from mice or touchpads, abstracting them both with the
--   <a>EventControllerScroll::scroll</a> signal. Deltas in the discrete
--   case are multiples of 1.
--   
--   In the case of continuous scroll events,
--   <tt>GtkEventControllerScroll</tt> encloses all
--   <a>EventControllerScroll::scroll</a> emissions between two
--   <a>EventControllerScroll::scrollBegin</a> and
--   <a>EventControllerScroll::scrollEnd</a> signals.
--   
--   The behavior of the event controller can be modified by the flags
--   given at creation time, or modified at a later point through
--   <a>eventControllerScrollSetFlags</a> (e.g. because the scrolling
--   conditions of the widget changed).
--   
--   The controller can be set up to emit motion for either/both vertical
--   and horizontal scroll events through
--   <a>EventControllerScrollFlagsVertical</a>,
--   <a>EventControllerScrollFlagsHorizontal</a> and
--   <a>EventControllerScrollFlagsBothAxes</a>. If any axis is disabled,
--   the respective <a>EventControllerScroll::scroll</a> delta will be 0.
--   Vertical scroll events will be translated to horizontal motion for the
--   devices incapable of horizontal scrolling.
--   
--   The event controller can also be forced to emit discrete events on all
--   devices through <a>EventControllerScrollFlagsDiscrete</a>. This can be
--   used to implement discrete actions triggered through scroll events
--   (e.g. switching across combobox options).
--   
--   The <a>EventControllerScrollFlagsKinetic</a> flag toggles the emission
--   of the <a>EventControllerScroll::decelerate</a> signal, emitted at the
--   end of scrolling with two X/Y velocity arguments that are consistent
--   with the motion that was received.
module GI.Gtk.Objects.EventControllerScroll

-- | Memory-managed wrapper type.
newtype EventControllerScroll
EventControllerScroll :: ManagedPtr EventControllerScroll -> EventControllerScroll

-- | Type class for types which can be safely cast to
--   <a>EventControllerScroll</a>, for instance with
--   <a>toEventControllerScroll</a>.
class (GObject o, IsDescendantOf EventControllerScroll o) => IsEventControllerScroll o

-- | Cast to <a>EventControllerScroll</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toEventControllerScroll :: (MonadIO m, IsEventControllerScroll o) => o -> m EventControllerScroll

-- | Gets the flags conditioning the scroll controller behavior.
eventControllerScrollGetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> m [EventControllerScrollFlags]

-- | Gets the scroll unit of the last <a>EventControllerScroll::scroll</a>
--   signal received.
--   
--   Always returns <a>ScrollUnitWheel</a> if the
--   <a>EventControllerScrollFlagsDiscrete</a> flag is set.
--   
--   <i>Since: 4.8</i>
eventControllerScrollGetUnit :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> m ScrollUnit

-- | Creates a new event controller that will handle scroll events.
eventControllerScrollNew :: (HasCallStack, MonadIO m) => [EventControllerScrollFlags] -> m EventControllerScroll

-- | Sets the flags conditioning scroll controller behavior.
eventControllerScrollSetFlags :: (HasCallStack, MonadIO m, IsEventControllerScroll a) => a -> [EventControllerScrollFlags] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEventControllerScrollFlags :: (IsEventControllerScroll o, MonadIO m) => [EventControllerScrollFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventControllerScroll #flags
--   </pre>
getEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> m [EventControllerScrollFlags]

-- | Set the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventControllerScroll [ #flags <a>:=</a> value ]
--   </pre>
setEventControllerScrollFlags :: (MonadIO m, IsEventControllerScroll o) => o -> [EventControllerScrollFlags] -> m ()

-- | Emitted after scroll is finished if the
--   <a>EventControllerScrollFlagsKinetic</a> flag is set.
--   
--   <i><tt>velX</tt></i> and <i><tt>velY</tt></i> express the initial
--   velocity that was imprinted by the scroll events. <i><tt>velX</tt></i>
--   and <i><tt>velY</tt></i> are expressed in pixels/ms.
type EventControllerScrollDecelerateCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>decelerate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #decelerate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollDecelerateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>decelerate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #decelerate callback
--   </pre>
onEventControllerScrollDecelerate :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollDecelerateCallback) -> m SignalHandlerId

-- | Signals that the widget should scroll by the amount specified by
--   <i><tt>dx</tt></i> and <i><tt>dy</tt></i>.
--   
--   For the representation unit of the deltas, see
--   <a>eventControllerScrollGetUnit</a>.
type EventControllerScrollScrollCallback = Double -> Double -> IO Bool

-- | Connect a signal handler for the <a>scroll</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #scroll callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scroll</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #scroll callback
--   </pre>
onEventControllerScrollScroll :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollCallback) -> m SignalHandlerId

-- | Signals that a new scrolling operation has begun.
--   
--   It will only be emitted on devices capable of it.
type EventControllerScrollScrollBeginCallback = IO ()

-- | Connect a signal handler for the <a>scrollBegin</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #scrollBegin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollBegin</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #scrollBegin callback
--   </pre>
onEventControllerScrollScrollBegin :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollBeginCallback) -> m SignalHandlerId

-- | Signals that a scrolling operation has finished.
--   
--   It will only be emitted on devices capable of it.
type EventControllerScrollScrollEndCallback = IO ()

-- | Connect a signal handler for the <a>scrollEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerScroll #scrollEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>scrollEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerScroll #scrollEnd callback
--   </pre>
onEventControllerScrollScrollEnd :: (IsEventControllerScroll a, MonadIO m) => a -> ((?self :: a) => EventControllerScrollScrollEndCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EventControllerScroll.EventControllerScroll
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerScroll.EventControllerScroll
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EventControllerScroll.EventControllerScroll
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EventControllerScroll.EventControllerScroll o) => GI.Gtk.Objects.EventControllerScroll.IsEventControllerScroll o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EventControllerScroll.EventControllerScroll)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EventControllerScroll.EventControllerScroll
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EventControllerScroll.EventControllerScroll


-- | Tracks the pointer position.
--   
--   The event controller offers <a>EventControllerMotion::enter</a> and
--   <a>EventControllerMotion::leave</a> signals, as well as
--   <a>EventControllerMotion:isPointer</a> and
--   <a>EventControllerMotion:containsPointer</a> properties which are
--   updated to reflect changes in the pointer position as it moves over
--   the widget.
module GI.Gtk.Objects.EventControllerMotion

-- | Memory-managed wrapper type.
newtype EventControllerMotion
EventControllerMotion :: ManagedPtr EventControllerMotion -> EventControllerMotion

-- | Type class for types which can be safely cast to
--   <a>EventControllerMotion</a>, for instance with
--   <a>toEventControllerMotion</a>.
class (GObject o, IsDescendantOf EventControllerMotion o) => IsEventControllerMotion o

-- | Cast to <a>EventControllerMotion</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toEventControllerMotion :: (MonadIO m, IsEventControllerMotion o) => o -> m EventControllerMotion

-- | Returns if a pointer is within <i><tt>self</tt></i> or one of its
--   children.
eventControllerMotionContainsPointer :: (HasCallStack, MonadIO m, IsEventControllerMotion a) => a -> m Bool

-- | Returns if a pointer is within <i><tt>self</tt></i>, but not one of
--   its children.
eventControllerMotionIsPointer :: (HasCallStack, MonadIO m, IsEventControllerMotion a) => a -> m Bool

-- | Creates a new event controller that will handle motion events.
eventControllerMotionNew :: (HasCallStack, MonadIO m) => m EventControllerMotion

-- | Get the value of the “<tt>contains-pointer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventControllerMotion #containsPointer
--   </pre>
getEventControllerMotionContainsPointer :: (MonadIO m, IsEventControllerMotion o) => o -> m Bool

-- | Get the value of the “<tt>is-pointer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventControllerMotion #isPointer
--   </pre>
getEventControllerMotionIsPointer :: (MonadIO m, IsEventControllerMotion o) => o -> m Bool

-- | Signals that the pointer has entered the widget.
type EventControllerMotionEnterCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>enter</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerMotion #enter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enter</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerMotion #enter callback
--   </pre>
onEventControllerMotionEnter :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionEnterCallback) -> m SignalHandlerId

-- | Signals that the pointer has left the widget.
type EventControllerMotionLeaveCallback = IO ()

-- | Connect a signal handler for the <a>leave</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerMotion #leave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerMotion #leave callback
--   </pre>
onEventControllerMotionLeave :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Emitted when the pointer moves inside the widget.
type EventControllerMotionMotionCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>motion</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerMotion #motion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerMotionMotion :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerMotion #motion callback
--   </pre>
onEventControllerMotionMotion :: (IsEventControllerMotion a, MonadIO m) => a -> ((?self :: a) => EventControllerMotionMotionCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EventControllerMotion.EventControllerMotion
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerMotion.EventControllerMotion
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EventControllerMotion.EventControllerMotion
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EventControllerMotion.EventControllerMotion o) => GI.Gtk.Objects.EventControllerMotion.IsEventControllerMotion o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EventControllerMotion.EventControllerMotion)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EventControllerMotion.EventControllerMotion
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EventControllerMotion.EventControllerMotion


-- | Provides raw access to the event stream.
--   
--   It should only be used as a last resort if none of the other event
--   controllers or gestures do the job.
module GI.Gtk.Objects.EventControllerLegacy

-- | Memory-managed wrapper type.
newtype EventControllerLegacy
EventControllerLegacy :: ManagedPtr EventControllerLegacy -> EventControllerLegacy

-- | Type class for types which can be safely cast to
--   <a>EventControllerLegacy</a>, for instance with
--   <a>toEventControllerLegacy</a>.
class (GObject o, IsDescendantOf EventControllerLegacy o) => IsEventControllerLegacy o

-- | Cast to <a>EventControllerLegacy</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toEventControllerLegacy :: (MonadIO m, IsEventControllerLegacy o) => o -> m EventControllerLegacy

-- | Creates a new legacy event controller.
eventControllerLegacyNew :: (HasCallStack, MonadIO m) => m EventControllerLegacy

-- | Emitted for each GDK event delivered to <i><tt>controller</tt></i>.
type EventControllerLegacyEventCallback = Event -> IO Bool

-- | Connect a signal handler for the <a>event</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerLegacy #event callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerLegacyEvent :: (IsEventControllerLegacy a, MonadIO m) => a -> ((?self :: a) => EventControllerLegacyEventCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>event</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerLegacy #event callback
--   </pre>
onEventControllerLegacyEvent :: (IsEventControllerLegacy a, MonadIO m) => a -> ((?self :: a) => EventControllerLegacyEventCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EventControllerLegacy.EventControllerLegacy
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerLegacy.EventControllerLegacy
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EventControllerLegacy.EventControllerLegacy
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EventControllerLegacy.EventControllerLegacy o) => GI.Gtk.Objects.EventControllerLegacy.IsEventControllerLegacy o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EventControllerLegacy.EventControllerLegacy)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EventControllerLegacy.EventControllerLegacy
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EventControllerLegacy.EventControllerLegacy


-- | Provides access to key events.
module GI.Gtk.Objects.EventControllerKey

-- | Memory-managed wrapper type.
newtype EventControllerKey
EventControllerKey :: ManagedPtr EventControllerKey -> EventControllerKey

-- | Type class for types which can be safely cast to
--   <a>EventControllerKey</a>, for instance with
--   <a>toEventControllerKey</a>.
class (GObject o, IsDescendantOf EventControllerKey o) => IsEventControllerKey o

-- | Cast to <a>EventControllerKey</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toEventControllerKey :: (MonadIO m, IsEventControllerKey o) => o -> m EventControllerKey

-- | Forwards the current event of this <i><tt>controller</tt></i> to a
--   <i><tt>widget</tt></i>.
--   
--   This function can only be used in handlers for the
--   <a>EventControllerKey::keyPressed</a>,
--   <a>EventControllerKey::keyReleased</a> or
--   <a>EventControllerKey::modifiers</a> signals.
eventControllerKeyForward :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsWidget b) => a -> b -> m Bool

-- | Gets the key group of the current event of this
--   <i><tt>controller</tt></i>.
--   
--   See <a>keyEventGetLayout</a>.
eventControllerKeyGetGroup :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m Word32

-- | Gets the input method context of the key <i><tt>controller</tt></i>.
eventControllerKeyGetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a) => a -> m (Maybe IMContext)

-- | Creates a new event controller that will handle key events.
eventControllerKeyNew :: (HasCallStack, MonadIO m) => m EventControllerKey

-- | Sets the input method context of the key <i><tt>controller</tt></i>.
eventControllerKeySetImContext :: (HasCallStack, MonadIO m, IsEventControllerKey a, IsIMContext b) => a -> Maybe b -> m ()

-- | Emitted whenever the input method context filters away a keypress and
--   prevents the <i><tt>controller</tt></i> receiving it.
--   
--   See <a>eventControllerKeySetImContext</a> and
--   <a>iMContextFilterKeypress</a>.
type EventControllerKeyImUpdateCallback = IO ()

-- | Connect a signal handler for the <a>imUpdate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #imUpdate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyImUpdateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>imUpdate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #imUpdate callback
--   </pre>
onEventControllerKeyImUpdate :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyImUpdateCallback) -> m SignalHandlerId

-- | Emitted whenever a key is pressed.
type EventControllerKeyKeyPressedCallback = Word32 -> Word32 -> [ModifierType] -> IO Bool

-- | Connect a signal handler for the <a>keyPressed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #keyPressed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyPressedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyPressed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #keyPressed callback
--   </pre>
onEventControllerKeyKeyPressed :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyPressedCallback) -> m SignalHandlerId

-- | Emitted whenever a key is released.
type EventControllerKeyKeyReleasedCallback = Word32 -> Word32 -> [ModifierType] -> IO ()

-- | Connect a signal handler for the <a>keyReleased</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #keyReleased callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyReleasedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>keyReleased</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #keyReleased callback
--   </pre>
onEventControllerKeyKeyReleased :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyKeyReleasedCallback) -> m SignalHandlerId

-- | Emitted whenever the state of modifier keys and pointer buttons
--   change.
type EventControllerKeyModifiersCallback = [ModifierType] -> IO Bool

-- | Connect a signal handler for the <a>modifiers</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerKey #modifiers callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyModifiersCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>modifiers</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerKey #modifiers callback
--   </pre>
onEventControllerKeyModifiers :: (IsEventControllerKey a, MonadIO m) => a -> ((?self :: a) => EventControllerKeyModifiersCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EventControllerKey.EventControllerKey
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerKey.EventControllerKey
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EventControllerKey.EventControllerKey
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EventControllerKey.EventControllerKey o) => GI.Gtk.Objects.EventControllerKey.IsEventControllerKey o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EventControllerKey.EventControllerKey)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EventControllerKey.EventControllerKey
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EventControllerKey.EventControllerKey


-- | Tracks keyboard focus.
--   
--   The event controller offers <a>EventControllerFocus::enter</a> and
--   <a>EventControllerFocus::leave</a> signals, as well as
--   <a>EventControllerFocus:isFocus</a> and
--   <a>EventControllerFocus:containsFocus</a> properties which are updated
--   to reflect focus changes inside the widget hierarchy that is rooted at
--   the controllers widget.
module GI.Gtk.Objects.EventControllerFocus

-- | Memory-managed wrapper type.
newtype EventControllerFocus
EventControllerFocus :: ManagedPtr EventControllerFocus -> EventControllerFocus

-- | Type class for types which can be safely cast to
--   <a>EventControllerFocus</a>, for instance with
--   <a>toEventControllerFocus</a>.
class (GObject o, IsDescendantOf EventControllerFocus o) => IsEventControllerFocus o

-- | Cast to <a>EventControllerFocus</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toEventControllerFocus :: (MonadIO m, IsEventControllerFocus o) => o -> m EventControllerFocus

-- | Returns <a>True</a> if focus is within <i><tt>self</tt></i> or one of
--   its children.
eventControllerFocusContainsFocus :: (HasCallStack, MonadIO m, IsEventControllerFocus a) => a -> m Bool

-- | Returns <a>True</a> if focus is within <i><tt>self</tt></i>, but not
--   one of its children.
eventControllerFocusIsFocus :: (HasCallStack, MonadIO m, IsEventControllerFocus a) => a -> m Bool

-- | Creates a new event controller that will handle focus events.
eventControllerFocusNew :: (HasCallStack, MonadIO m) => m EventControllerFocus

-- | Get the value of the “<tt>contains-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventControllerFocus #containsFocus
--   </pre>
getEventControllerFocusContainsFocus :: (MonadIO m, IsEventControllerFocus o) => o -> m Bool

-- | Get the value of the “<tt>is-focus</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventControllerFocus #isFocus
--   </pre>
getEventControllerFocusIsFocus :: (MonadIO m, IsEventControllerFocus o) => o -> m Bool

-- | Emitted whenever the focus enters into the widget or one of its
--   descendents.
--   
--   Note that this means you may not get an <a>enter</a> signal even
--   though the widget becomes the focus location, in certain cases (such
--   as when the focus moves from a descendent of the widget to the widget
--   itself). If you are interested in these cases, you can monitor the
--   <a>EventControllerFocus:isFocus</a> property for changes.
type EventControllerFocusEnterCallback = IO ()

-- | Connect a signal handler for the <a>enter</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerFocus #enter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerFocusEnter :: (IsEventControllerFocus a, MonadIO m) => a -> ((?self :: a) => EventControllerFocusEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enter</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerFocus #enter callback
--   </pre>
onEventControllerFocusEnter :: (IsEventControllerFocus a, MonadIO m) => a -> ((?self :: a) => EventControllerFocusEnterCallback) -> m SignalHandlerId

-- | Emitted whenever the focus leaves the widget hierarchy that is rooted
--   at the widget that the controller is attached to.
--   
--   Note that this means you may not get a <a>leave</a> signal even though
--   the focus moves away from the widget, in certain cases (such as when
--   the focus moves from the widget to a descendent). If you are
--   interested in these cases, you can monitor the
--   <a>EventControllerFocus:isFocus</a> property for changes.
type EventControllerFocusLeaveCallback = IO ()

-- | Connect a signal handler for the <a>leave</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> eventControllerFocus #leave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEventControllerFocusLeave :: (IsEventControllerFocus a, MonadIO m) => a -> ((?self :: a) => EventControllerFocusLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> eventControllerFocus #leave callback
--   </pre>
onEventControllerFocusLeave :: (IsEventControllerFocus a, MonadIO m) => a -> ((?self :: a) => EventControllerFocusLeaveCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EventControllerFocus.EventControllerFocus
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventControllerFocus.EventControllerFocus
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EventControllerFocus.EventControllerFocus
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EventControllerFocus.EventControllerFocus o) => GI.Gtk.Objects.EventControllerFocus.IsEventControllerFocus o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EventControllerFocus.EventControllerFocus)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EventControllerFocus.EventControllerFocus
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EventControllerFocus.EventControllerFocus


-- | The base class for event controllers.
--   
--   These are ancillary objects associated to widgets, which react to
--   <tt>GdkEvents</tt>, and possibly trigger actions as a consequence.
--   
--   Event controllers are added to a widget with
--   <a>widgetAddController</a>. It is rarely necessary to explicitly
--   remove a controller with <a>widgetRemoveController</a>.
--   
--   See the chapter on <a>input handling</a> for an overview of the basic
--   concepts, such as the capture and bubble phases of event propagation.
module GI.Gtk.Objects.EventController

-- | Memory-managed wrapper type.
newtype EventController
EventController :: ManagedPtr EventController -> EventController

-- | Type class for types which can be safely cast to
--   <a>EventController</a>, for instance with <a>toEventController</a>.
class (GObject o, IsDescendantOf EventController o) => IsEventController o

-- | Cast to <a>EventController</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toEventController :: (MonadIO m, IsEventController o) => o -> m EventController

-- | Returns the event that is currently being handled by the controller.
--   
--   At other times, <a>Nothing</a> is returned.
eventControllerGetCurrentEvent :: (HasCallStack, MonadIO m, IsEventController a) => a -> m (Maybe Event)

-- | Returns the device of the event that is currently being handled by the
--   controller.
--   
--   At other times, <a>Nothing</a> is returned.
eventControllerGetCurrentEventDevice :: (HasCallStack, MonadIO m, IsEventController a) => a -> m (Maybe Device)

-- | Returns the modifier state of the event that is currently being
--   handled by the controller.
--   
--   At other times, 0 is returned.
eventControllerGetCurrentEventState :: (HasCallStack, MonadIO m, IsEventController a) => a -> m [ModifierType]

-- | Returns the timestamp of the event that is currently being handled by
--   the controller.
--   
--   At other times, 0 is returned.
eventControllerGetCurrentEventTime :: (HasCallStack, MonadIO m, IsEventController a) => a -> m Word32

-- | Gets the name of <i><tt>controller</tt></i>.
eventControllerGetName :: (HasCallStack, MonadIO m, IsEventController a) => a -> m (Maybe Text)

-- | Gets the propagation limit of the event controller.
eventControllerGetPropagationLimit :: (HasCallStack, MonadIO m, IsEventController a) => a -> m PropagationLimit

-- | Gets the propagation phase at which <i><tt>controller</tt></i> handles
--   events.
eventControllerGetPropagationPhase :: (HasCallStack, MonadIO m, IsEventController a) => a -> m PropagationPhase

-- | Returns the <tt>GtkWidget</tt> this controller relates to.
eventControllerGetWidget :: (HasCallStack, MonadIO m, IsEventController a) => a -> m (Maybe Widget)

-- | Resets the <i><tt>controller</tt></i> to a clean state.
eventControllerReset :: (HasCallStack, MonadIO m, IsEventController a) => a -> m ()

-- | Sets a name on the controller that can be used for debugging.
eventControllerSetName :: (HasCallStack, MonadIO m, IsEventController a) => a -> Maybe Text -> m ()

-- | Sets the event propagation limit on the event controller.
--   
--   If the limit is set to <a>PropagationLimitSameNative</a>, the
--   controller won't handle events that are targeted at widgets on a
--   different surface, such as popovers.
eventControllerSetPropagationLimit :: (HasCallStack, MonadIO m, IsEventController a) => a -> PropagationLimit -> m ()

-- | Sets the propagation phase at which a controller handles events.
--   
--   If <i><tt>phase</tt></i> is <a>PropagationPhaseNone</a>, no automatic
--   event handling will be performed, but other additional gesture
--   maintenance will.
eventControllerSetPropagationPhase :: (HasCallStack, MonadIO m, IsEventController a) => a -> PropagationPhase -> m ()

-- | Sets a name on the controller that can be used for debugging.
--   
--   <i>Since: 4.8</i>
eventControllerSetStaticName :: (HasCallStack, MonadIO m, IsEventController a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>name</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #name
--   </pre>
clearEventControllerName :: (MonadIO m, IsEventController o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>name</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEventControllerName :: (IsEventController o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventController #name
--   </pre>
getEventControllerName :: (MonadIO m, IsEventController o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventController [ #name <a>:=</a> value ]
--   </pre>
setEventControllerName :: (MonadIO m, IsEventController o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagation-limit</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEventControllerPropagationLimit :: (IsEventController o, MonadIO m) => PropagationLimit -> m (GValueConstruct o)

-- | Get the value of the “<tt>propagation-limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventController #propagationLimit
--   </pre>
getEventControllerPropagationLimit :: (MonadIO m, IsEventController o) => o -> m PropagationLimit

-- | Set the value of the “<tt>propagation-limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventController [ #propagationLimit <a>:=</a> value ]
--   </pre>
setEventControllerPropagationLimit :: (MonadIO m, IsEventController o) => o -> PropagationLimit -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>propagation-phase</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEventControllerPropagationPhase :: (IsEventController o, MonadIO m) => PropagationPhase -> m (GValueConstruct o)

-- | Get the value of the “<tt>propagation-phase</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventController #propagationPhase
--   </pre>
getEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> m PropagationPhase

-- | Set the value of the “<tt>propagation-phase</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> eventController [ #propagationPhase <a>:=</a> value ]
--   </pre>
setEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> PropagationPhase -> m ()

-- | Get the value of the “<tt>widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> eventController #widget
--   </pre>
getEventControllerWidget :: (MonadIO m, IsEventController o) => o -> m (Maybe Widget)
instance GHC.Classes.Eq GI.Gtk.Objects.EventController.EventController
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EventController.EventController
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EventController.EventController
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EventController.EventController o) => GI.Gtk.Objects.EventController.IsEventController o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EventController.EventController)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EventController.EventController
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EventController.EventController


-- | <tt>GtkEntryCompletion</tt> is an auxiliary object to provide
--   completion functionality for <tt>GtkEntry</tt>.
--   
--   It implements the <a>CellLayout</a> interface, to allow the user to
--   add extra cells to the <tt>GtkTreeView</tt> with completion matches.
--   
--   “Completion functionality” means that when the user modifies the text
--   in the entry, <tt>GtkEntryCompletion</tt> checks which rows in the
--   model match the current content of the entry, and displays a list of
--   matches. By default, the matching is done by comparing the entry text
--   case-insensitively against the text column of the model (see
--   <a>entryCompletionSetTextColumn</a>), but this can be overridden with
--   a custom match function (see <a>entryCompletionSetMatchFunc</a>).
--   
--   When the user selects a completion, the content of the entry is
--   updated. By default, the content of the entry is replaced by the text
--   column of the model, but this can be overridden by connecting to the
--   <a>EntryCompletion::matchSelected</a> signal and updating the entry in
--   the signal handler. Note that you should return <a>True</a> from the
--   signal handler to suppress the default behaviour.
--   
--   To add completion functionality to an entry, use
--   <a>entrySetCompletion</a>.
--   
--   <tt>GtkEntryCompletion</tt> uses a <a>TreeModelFilter</a> model to
--   represent the subset of the entire model that is currently matching.
--   While the <tt>GtkEntryCompletion</tt> signals
--   <a>EntryCompletion::matchSelected</a> and
--   <a>EntryCompletion::cursorOnMatch</a> take the original model and an
--   iter pointing to that model as arguments, other callbacks and signals
--   (such as <tt>GtkCellLayoutDataFunc</tt> or
--   <a>signal<i><tt>gtk</tt></i>.CellArea[applyAttributes</a>)] will
--   generally take the filter model as argument. As long as you are only
--   calling <a>TreeModel</a>.<tt><i>get</i></tt>(), this will make no
--   difference to you. If for some reason, you need the original model,
--   use <a>treeModelFilterGetModel</a>. Don’t forget to use
--   <a>treeModelFilterConvertIterToChildIter</a> to obtain a matching
--   iter.
module GI.Gtk.Objects.EntryCompletion

-- | Memory-managed wrapper type.
newtype EntryCompletion
EntryCompletion :: ManagedPtr EntryCompletion -> EntryCompletion

-- | Type class for types which can be safely cast to
--   <a>EntryCompletion</a>, for instance with <a>toEntryCompletion</a>.
class (GObject o, IsDescendantOf EntryCompletion o) => IsEntryCompletion o

-- | Cast to <a>EntryCompletion</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toEntryCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m EntryCompletion

-- | Requests a completion operation, or in other words a refiltering of
--   the current list with completions, using the current key.
--   
--   The completion list view will be updated accordingly.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionComplete :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m ()

-- | Computes the common prefix that is shared by all rows in
--   <i><tt>completion</tt></i> that start with <i><tt>key</tt></i>.
--   
--   If no row matches <i><tt>key</tt></i>, <a>Nothing</a> will be
--   returned. Note that a text column must have been set for this function
--   to work, see <a>entryCompletionSetTextColumn</a> for details.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionComputePrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Text -> m (Maybe Text)

-- | Get the original text entered by the user that triggered the
--   completion or <a>Nothing</a> if there’s no completion ongoing.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetCompletionPrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m (Maybe Text)

-- | Gets the entry <i><tt>completion</tt></i> has been attached to.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetEntry :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Widget

-- | Returns whether the common prefix of the possible completions should
--   be automatically inserted in the entry.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetInlineCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns <a>True</a> if inline-selection mode is turned on.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetInlineSelection :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns the minimum key length as set for <i><tt>completion</tt></i>.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetMinimumKeyLength :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Int32

-- | Returns the model the <tt>GtkEntryCompletion</tt> is using as data
--   source.
--   
--   Returns <a>Nothing</a> if the model is unset.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m (Maybe TreeModel)

-- | Returns whether the completions should be presented in a popup window.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetPopupCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns whether the completion popup window will be resized to the
--   width of the entry.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetPopupSetWidth :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns whether the completion popup window will appear even if there
--   is only a single match.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetPopupSingleMatch :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Bool

-- | Returns the column in the model of <i><tt>completion</tt></i> to get
--   strings from.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionGetTextColumn :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m Int32

-- | Requests a prefix insertion.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionInsertPrefix :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> m ()

-- | Creates a new <tt>GtkEntryCompletion</tt> object.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionNew :: (HasCallStack, MonadIO m) => m EntryCompletion

-- | Creates a new <tt>GtkEntryCompletion</tt> object using the specified
--   <i><tt>area</tt></i>.
--   
--   The <tt>GtkCellArea</tt> is used to layout cells in the underlying
--   <tt>GtkTreeViewColumn</tt> for the drop-down menu.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionNewWithArea :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m EntryCompletion

-- | Sets whether the common prefix of the possible completions should be
--   automatically inserted in the entry.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetInlineCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets whether it is possible to cycle through the possible completions
--   inside the entry.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetInlineSelection :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets the match function for <i><tt>completion</tt></i> to be
--   <i><tt>func</tt></i>.
--   
--   The match function is used to determine if a row should or should not
--   be in the completion list.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetMatchFunc :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> EntryCompletionMatchFunc -> m ()

-- | Requires the length of the search key for <i><tt>completion</tt></i>
--   to be at least <i><tt>length</tt></i>.
--   
--   This is useful for long lists, where completing using a small key
--   takes a lot of time and will come up with meaningless results anyway
--   (ie, a too large dataset).

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetMinimumKeyLength :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Sets the model for a <tt>GtkEntryCompletion</tt>.
--   
--   If <i><tt>completion</tt></i> already has a model set, it will remove
--   it before setting the new model. If model is <a>Nothing</a>, then it
--   will unset the model.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetModel :: (HasCallStack, MonadIO m, IsEntryCompletion a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Sets whether the completions should be presented in a popup window.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetPopupCompletion :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets whether the completion popup window will be resized to be the
--   same width as the entry.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetPopupSetWidth :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Sets whether the completion popup window will appear even if there is
--   only a single match.
--   
--   You may want to set this to <a>False</a> if you are using
--   <a>EntryCompletion:inlineCompletion</a>.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetPopupSingleMatch :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Bool -> m ()

-- | Convenience function for setting up the most used case of this code: a
--   completion list with just strings.
--   
--   This function will set up <i><tt>completion</tt></i> to have a list
--   displaying all (and just) strings in the completion list, and to get
--   those strings from <i><tt>column</tt></i> in the model of
--   <i><tt>completion</tt></i>.
--   
--   This functions creates and adds a <tt>GtkCellRendererText</tt> for the
--   selected column. If you need to set the text column, but don't want
--   the cell renderer, use <tt><i>g_object_set()</i></tt> to set the
--   <a>EntryCompletion:textColumn</a> property directly.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryCompletionSetTextColumn :: (HasCallStack, MonadIO m, IsEntryCompletion a) => a -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryCompletionCellArea :: (IsEntryCompletion o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #cellArea
--   </pre>
getEntryCompletionCellArea :: (MonadIO m, IsEntryCompletion o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inline-completion</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionInlineCompletion :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inline-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #inlineCompletion
--   </pre>
getEntryCompletionInlineCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>inline-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #inlineCompletion <a>:=</a> value ]
--   </pre>
setEntryCompletionInlineCompletion :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inline-selection</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionInlineSelection :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inline-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #inlineSelection
--   </pre>
getEntryCompletionInlineSelection :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>inline-selection</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #inlineSelection <a>:=</a> value ]
--   </pre>
setEntryCompletionInlineSelection :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>minimum-key-length</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryCompletionMinimumKeyLength :: (IsEntryCompletion o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>minimum-key-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #minimumKeyLength
--   </pre>
getEntryCompletionMinimumKeyLength :: (MonadIO m, IsEntryCompletion o) => o -> m Int32

-- | Set the value of the “<tt>minimum-key-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #minimumKeyLength <a>:=</a> value ]
--   </pre>
setEntryCompletionMinimumKeyLength :: (MonadIO m, IsEntryCompletion o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearEntryCompletionModel :: (MonadIO m, IsEntryCompletion o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryCompletionModel :: (IsEntryCompletion o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #model
--   </pre>
getEntryCompletionModel :: (MonadIO m, IsEntryCompletion o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #model <a>:=</a> value ]
--   </pre>
setEntryCompletionModel :: (MonadIO m, IsEntryCompletion o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-completion</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionPopupCompletion :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>popup-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #popupCompletion
--   </pre>
getEntryCompletionPopupCompletion :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>popup-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #popupCompletion <a>:=</a> value ]
--   </pre>
setEntryCompletionPopupCompletion :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-set-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryCompletionPopupSetWidth :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>popup-set-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #popupSetWidth
--   </pre>
getEntryCompletionPopupSetWidth :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>popup-set-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #popupSetWidth <a>:=</a> value ]
--   </pre>
setEntryCompletionPopupSetWidth :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-single-match</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryCompletionPopupSingleMatch :: (IsEntryCompletion o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>popup-single-match</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #popupSingleMatch
--   </pre>
getEntryCompletionPopupSingleMatch :: (MonadIO m, IsEntryCompletion o) => o -> m Bool

-- | Set the value of the “<tt>popup-single-match</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #popupSingleMatch <a>:=</a> value ]
--   </pre>
setEntryCompletionPopupSingleMatch :: (MonadIO m, IsEntryCompletion o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryCompletionTextColumn :: (IsEntryCompletion o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entryCompletion #textColumn
--   </pre>
getEntryCompletionTextColumn :: (MonadIO m, IsEntryCompletion o) => o -> m Int32

-- | Set the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entryCompletion [ #textColumn <a>:=</a> value ]
--   </pre>
setEntryCompletionTextColumn :: (MonadIO m, IsEntryCompletion o) => o -> Int32 -> m ()

-- | Emitted when a match from the cursor is on a match of the list.
--   
--   The default behaviour is to replace the contents of the entry with the
--   contents of the text column in the row pointed to by
--   <i><tt>iter</tt></i>.
--   
--   Note that <i><tt>model</tt></i> is the model that was passed to
--   <a>entryCompletionSetModel</a>.
type EntryCompletionCursorOnMatchCallback = TreeModel -> TreeIter -> IO Bool

-- | Connect a signal handler for the <a>cursorOnMatch</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #cursorOnMatch callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionCursorOnMatch :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionCursorOnMatchCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cursorOnMatch</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #cursorOnMatch callback
--   </pre>
onEntryCompletionCursorOnMatch :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionCursorOnMatchCallback) -> m SignalHandlerId

-- | Emitted when the inline autocompletion is triggered.
--   
--   The default behaviour is to make the entry display the whole prefix
--   and select the newly inserted part.
--   
--   Applications may connect to this signal in order to insert only a
--   smaller part of the <i><tt>prefix</tt></i> into the entry - e.g. the
--   entry used in the <tt>GtkFileChooser</tt> inserts only the part of the
--   prefix up to the next '/'.
type EntryCompletionInsertPrefixCallback = Text -> IO Bool

-- | Connect a signal handler for the <a>insertPrefix</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #insertPrefix callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionInsertPrefix :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionInsertPrefixCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertPrefix</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #insertPrefix callback
--   </pre>
onEntryCompletionInsertPrefix :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionInsertPrefixCallback) -> m SignalHandlerId

-- | Emitted when a match from the list is selected.
--   
--   The default behaviour is to replace the contents of the entry with the
--   contents of the text column in the row pointed to by
--   <i><tt>iter</tt></i>.
--   
--   Note that <i><tt>model</tt></i> is the model that was passed to
--   <a>entryCompletionSetModel</a>.
type EntryCompletionMatchSelectedCallback = TreeModel -> TreeIter -> IO Bool

-- | Connect a signal handler for the <a>matchSelected</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #matchSelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionMatchSelected :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionMatchSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>matchSelected</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #matchSelected callback
--   </pre>
onEntryCompletionMatchSelected :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionMatchSelectedCallback) -> m SignalHandlerId

-- | Emitted when the filter model has zero number of rows in
--   completion_complete method.
--   
--   In other words when <tt>GtkEntryCompletion</tt> is out of suggestions.
type EntryCompletionNoMatchesCallback = IO ()

-- | Connect a signal handler for the <a>noMatches</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entryCompletion #noMatches callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryCompletionNoMatches :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionNoMatchesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>noMatches</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entryCompletion #noMatches callback
--   </pre>
onEntryCompletionNoMatches :: (IsEntryCompletion a, MonadIO m) => a -> ((?self :: a) => EntryCompletionNoMatchesCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EntryCompletion.EntryCompletion
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EntryCompletion.EntryCompletion
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EntryCompletion.EntryCompletion
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EntryCompletion.EntryCompletion o) => GI.Gtk.Objects.EntryCompletion.IsEntryCompletion o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EntryCompletion.EntryCompletion)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EntryCompletion.EntryCompletion
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EntryCompletion.EntryCompletion


-- | A single-line text entry widget.
--   
--   &lt;picture&gt; &lt;source srcset="entry-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkEntry" src="entry.png"&gt; &lt;/picture&gt;
--   
--   A fairly large set of key bindings are supported by default. If the
--   entered text is longer than the allocation of the widget, the widget
--   will scroll so that the cursor position is visible.
--   
--   When using an entry for passwords and other sensitive information, it
--   can be put into “password mode” using <a>entrySetVisibility</a>. In
--   this mode, entered text is displayed using a “invisible” character. By
--   default, GTK picks the best invisible character that is available in
--   the current font, but it can be changed with
--   <a>entrySetInvisibleChar</a>.
--   
--   <tt>GtkEntry</tt> has the ability to display progress or activity
--   information behind the text. To make an entry display such
--   information, use <a>entrySetProgressFraction</a> or
--   <a>entrySetProgressPulseStep</a>.
--   
--   Additionally, <tt>GtkEntry</tt> can show icons at either side of the
--   entry. These icons can be activatable by clicking, can be set up as
--   drag source and can have tooltips. To add an icon, use
--   <a>entrySetIconFromGicon</a> or one of the various other functions
--   that set an icon from an icon name or a paintable. To trigger an
--   action when the user clicks an icon, connect to the
--   <a>Entry::iconPress</a> signal. To allow DND operations from an icon,
--   use <a>entrySetIconDragSource</a>. To set a tooltip on an icon, use
--   <a>entrySetIconTooltipText</a> or the corresponding function for
--   markup.
--   
--   Note that functionality or information that is only available by
--   clicking on an icon in an entry may not be accessible at all to users
--   which are not able to use a mouse or other pointing device. It is
--   therefore recommended that any such functionality should also be
--   available by other means, e.g. via the context menu of the entry.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   entry[.flat][.warning][.error]
--   ├── text[.readonly]
--   ├── image.left
--   ├── image.right
--   ╰── [progress[.pulse]]
--   </pre>
--   
--   <tt>GtkEntry</tt> has a main node with the name entry. Depending on
--   the properties of the entry, the style classes .read-only and .flat
--   may appear. The style classes .warning and .error may also be used
--   with entries.
--   
--   When the entry shows icons, it adds subnodes with the name image and
--   the style class .left or .right, depending on where the icon appears.
--   
--   When the entry shows progress, it adds a subnode with the name
--   progress. The node has the style class .pulse when the shown progress
--   is pulsing.
--   
--   For all the subnodes added to the text node in various situations, see
--   <a>Text</a>.
--   
--   <h1>GtkEntry as GtkBuildable</h1>
--   
--   The <tt>GtkEntry</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports a custom <tt>&lt;attributes&gt;</tt> element, which
--   supports any number of <tt>&lt;attribute&gt;</tt> elements. The
--   <tt>&lt;attribute&gt;</tt> element has attributes named “name“,
--   “value“, “start“ and “end“ and allows you to specify
--   <tt>PangoAttribute</tt> values for this label.
--   
--   An example of a UI definition fragment specifying Pango attributes:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkEntry"&gt;
--     &lt;attributes&gt;
--       &lt;attribute name="weight" value="PANGO_WEIGHT_BOLD"/&gt;
--       &lt;attribute name="background" value="red" start="5" end="10"/&gt;
--     &lt;/attributes&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   The start and end attributes specify the range of characters to which
--   the Pango attribute applies. If start and end are not specified, the
--   attribute is applied to the whole text. Note that specifying ranges
--   does not make much sense with translatable attributes. Use markup
--   embedded in the translatable content instead.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkEntry</tt> uses the <a>AccessibleRoleTextBox</a> role.
module GI.Gtk.Objects.Entry

-- | Memory-managed wrapper type.
newtype Entry
Entry :: ManagedPtr Entry -> Entry

-- | Type class for types which can be safely cast to <a>Entry</a>, for
--   instance with <a>toEntry</a>.
class (GObject o, IsDescendantOf Entry o) => IsEntry o

-- | Cast to <a>Entry</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toEntry :: (MonadIO m, IsEntry o) => o -> m Entry

-- | Retrieves the value set by <a>entrySetActivatesDefault</a>.
entryGetActivatesDefault :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Gets the value set by <a>entrySetAlignment</a>.
--   
--   See also: <a>Editable:xalign</a>
entryGetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Float

-- | Gets the attribute list of the <tt>GtkEntry</tt>.
--   
--   See <a>entrySetAttributes</a>.
entryGetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe AttrList)

-- | Get the <tt>GtkEntryBuffer</tt> object which holds the text for this
--   widget.
entryGetBuffer :: (HasCallStack, MonadIO m, IsEntry a) => a -> m EntryBuffer

-- | Returns the auxiliary completion object currently in use by
--   <i><tt>entry</tt></i>.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entryGetCompletion :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe EntryCompletion)

-- | Returns the index of the icon which is the source of the current DND
--   operation, or -1.
entryGetCurrentIconDragSource :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Gets the menu model set with <a>entrySetExtraMenu</a>.
entryGetExtraMenu :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe MenuModel)

-- | Gets the value set by <a>entrySetHasFrame</a>.
entryGetHasFrame :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Returns whether the icon is activatable.
entryGetIconActivatable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool

-- | Gets the area where entry’s icon at <i><tt>iconPos</tt></i> is drawn.
--   
--   This function is useful when drawing something to the entry in a draw
--   callback.
--   
--   If the entry is not realized or has no icon at the given position,
--   <i><tt>iconArea</tt></i> is filled with zeros. Otherwise,
--   <i><tt>iconArea</tt></i> will be filled with the icon's allocation,
--   relative to <i><tt>entry</tt></i>'s allocation.
entryGetIconArea :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Rectangle

-- | Finds the icon at the given position and return its index.
--   
--   The position’s coordinates are relative to the <i><tt>entry</tt></i>’s
--   top left corner. If <i><tt>x</tt></i>, <i><tt>y</tt></i> doesn’t lie
--   inside an icon, -1 is returned. This function is intended for use in a
--   <a>Widget::queryTooltip</a> signal handler.
entryGetIconAtPos :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> Int32 -> m Int32

-- | Retrieves the <tt>GIcon</tt> used for the icon.
--   
--   <a>Nothing</a> will be returned if there is no icon or if the icon was
--   set by some other method (e.g., by <tt>GdkPaintable</tt> or icon
--   name).
entryGetIconGicon :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Icon)

-- | Retrieves the icon name used for the icon.
--   
--   <a>Nothing</a> is returned if there is no icon or if the icon was set
--   by some other method (e.g., by <tt>GdkPaintable</tt> or gicon).
entryGetIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | Retrieves the <tt>GdkPaintable</tt> used for the icon.
--   
--   If no <tt>GdkPaintable</tt> was used for the icon, <a>Nothing</a> is
--   returned.
entryGetIconPaintable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Paintable)

-- | Returns whether the icon appears sensitive or insensitive.
entryGetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m Bool

-- | Gets the type of representation being used by the icon to store image
--   data.
--   
--   If the icon has no image data, the return value will be
--   <a>ImageTypeEmpty</a>.
entryGetIconStorageType :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m ImageType

-- | Gets the contents of the tooltip on the icon at the specified position
--   in <i><tt>entry</tt></i>.
entryGetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | Gets the contents of the tooltip on the icon at the specified position
--   in <i><tt>entry</tt></i>.
entryGetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | Gets the input hints of this <tt>GtkEntry</tt>.
entryGetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> m [InputHints]

-- | Gets the input purpose of the <tt>GtkEntry</tt>.
entryGetInputPurpose :: (HasCallStack, MonadIO m, IsEntry a) => a -> m InputPurpose

-- | Retrieves the character displayed in place of the actual text in
--   “password mode”.
entryGetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Char

-- | Retrieves the maximum allowed length of the text in
--   <i><tt>entry</tt></i>.
--   
--   See <a>entrySetMaxLength</a>.
entryGetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Int32

-- | Gets the text that will be used in the context menu of the
--   <tt>GtkEntry</tt> when the specified icon is activatable. Selecting
--   this item in the menu results, from all aspects, the same than
--   clicking on the specified icon. This greatly simplifies making
--   accessible applications, because the icons aren't focusable when using
--   keyboard navigation. This is why Gtk recommends to add the same action
--   to the context menu.
--   
--   <i>Since: 4.20</i>
entryGetMenuEntryIconText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> m (Maybe Text)

-- | Gets whether the <tt>GtkEntry</tt> is in overwrite mode.
entryGetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Retrieves the text that will be displayed when <i><tt>entry</tt></i>
--   is empty and unfocused
entryGetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe Text)

-- | Returns the current fraction of the task that’s been completed.
--   
--   See <a>entrySetProgressFraction</a>.
entryGetProgressFraction :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double

-- | Retrieves the pulse step set with <a>entrySetProgressPulseStep</a>.
entryGetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Double

-- | Gets the tabstops of the <tt>GtkEntry</tt>.
--   
--   See <a>entrySetTabs</a>.
entryGetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> m (Maybe TabArray)

-- | Retrieves the current length of the text in <i><tt>entry</tt></i>.
--   
--   This is equivalent to getting <i><tt>entry</tt></i>'s
--   <tt>GtkEntryBuffer</tt> and calling <a>entryBufferGetLength</a> on it.
entryGetTextLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Word16

-- | Retrieves whether the text in <i><tt>entry</tt></i> is visible.
--   
--   See <a>entrySetVisibility</a>.
entryGetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Causes <i><tt>entry</tt></i> to have keyboard focus.
--   
--   It behaves like <a>widgetGrabFocus</a>, except that it doesn't select
--   the contents of the entry. You only want to call this on some special
--   entries which the user usually doesn't want to replace all text in,
--   such as search-as-you-type entries.
entryGrabFocusWithoutSelecting :: (HasCallStack, MonadIO m, IsEntry a) => a -> m Bool

-- | Creates a new entry.
entryNew :: (HasCallStack, MonadIO m) => m Entry

-- | Creates a new entry with the specified text buffer.
entryNewWithBuffer :: (HasCallStack, MonadIO m, IsEntryBuffer a) => a -> m Entry

-- | Indicates that some progress is made, but you don’t know how much.
--   
--   Causes the entry’s progress indicator to enter “activity mode”, where
--   a block bounces back and forth. Each call to <a>entryProgressPulse</a>
--   causes the block to move by a little bit (the amount of movement per
--   pulse is determined by <a>entrySetProgressPulseStep</a>).
entryProgressPulse :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Reset the input method context of the entry if needed.
--   
--   This can be necessary in the case where modifying the buffer would
--   confuse on-going input method behavior.
entryResetImContext :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Sets whether pressing Enter in the <i><tt>entry</tt></i> will activate
--   the default widget for the window containing the entry.
--   
--   This usually means that the dialog containing the entry will be
--   closed, since the default widget is usually one of the dialog buttons.
entrySetActivatesDefault :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Sets the alignment for the contents of the entry.
--   
--   This controls the horizontal positioning of the contents when the
--   displayed text is shorter than the width of the entry.
--   
--   See also: <a>Editable:xalign</a>
entrySetAlignment :: (HasCallStack, MonadIO m, IsEntry a) => a -> Float -> m ()

-- | Sets a <tt>PangoAttrList</tt>.
--   
--   The attributes in the list are applied to the entry text.
--   
--   Since the attributes will be applied to text that changes as the user
--   types, it makes most sense to use attributes with unlimited extent.
entrySetAttributes :: (HasCallStack, MonadIO m, IsEntry a) => a -> AttrList -> m ()

-- | Set the <tt>GtkEntryBuffer</tt> object which holds the text for this
--   widget.
entrySetBuffer :: (HasCallStack, MonadIO m, IsEntry a, IsEntryBuffer b) => a -> b -> m ()

-- | Sets <i><tt>completion</tt></i> to be the auxiliary completion object
--   to use with <i><tt>entry</tt></i>.
--   
--   All further configuration of the completion mechanism is done on
--   <i><tt>completion</tt></i> using the <tt>GtkEntryCompletion</tt> API.
--   Completion is disabled if <i><tt>completion</tt></i> is set to
--   <a>Nothing</a>.

-- | <i>Deprecated: (Since version 4.10)GtkEntryCompletion will be removed
--   in GTK 5.</i>
entrySetCompletion :: (HasCallStack, MonadIO m, IsEntry a, IsEntryCompletion b) => a -> Maybe b -> m ()

-- | Sets a menu model to add when constructing the context menu for
--   <i><tt>entry</tt></i>.
entrySetExtraMenu :: (HasCallStack, MonadIO m, IsEntry a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets whether the entry has a beveled frame around it.
entrySetHasFrame :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Sets whether the icon is activatable.
entrySetIconActivatable :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Bool -> m ()

-- | Sets up the icon at the given position as drag source.
--   
--   This makes it so that GTK will start a drag operation when the user
--   clicks and drags the icon.
entrySetIconDragSource :: (HasCallStack, MonadIO m, IsEntry a, IsContentProvider b) => a -> EntryIconPosition -> b -> [DragAction] -> m ()

-- | Sets the icon shown in the entry at the specified position from the
--   current icon theme.
--   
--   If the icon isn’t known, a “broken image” icon will be displayed
--   instead.
--   
--   If <i><tt>icon</tt></i> is <a>Nothing</a>, no icon will be shown in
--   the specified position.
entrySetIconFromGicon :: (HasCallStack, MonadIO m, IsEntry a, IsIcon b) => a -> EntryIconPosition -> Maybe b -> m ()

-- | Sets the icon shown in the entry at the specified position from the
--   current icon theme.
--   
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead.
--   
--   If <i><tt>iconName</tt></i> is <a>Nothing</a>, no icon will be shown
--   in the specified position.
entrySetIconFromIconName :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets the icon shown in the specified position using a
--   <tt>GdkPaintable</tt>.
--   
--   If <i><tt>paintable</tt></i> is <a>Nothing</a>, no icon will be shown
--   in the specified position.
entrySetIconFromPaintable :: (HasCallStack, MonadIO m, IsEntry a, IsPaintable b) => a -> EntryIconPosition -> Maybe b -> m ()

-- | Sets the sensitivity for the specified icon.
entrySetIconSensitive :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Bool -> m ()

-- | Sets <i><tt>tooltip</tt></i> as the contents of the tooltip for the
--   icon at the specified position.
--   
--   <i><tt>tooltip</tt></i> is assumed to be marked up with Pango Markup.
--   
--   Use <a>Nothing</a> for <i><tt>tooltip</tt></i> to remove an existing
--   tooltip.
--   
--   See also <a>widgetSetTooltipMarkup</a> and
--   <a>entrySetIconTooltipText</a>.
entrySetIconTooltipMarkup :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Sets <i><tt>tooltip</tt></i> as the contents of the tooltip for the
--   icon at the specified position.
--   
--   Use <a>Nothing</a> for <i><tt>tooltip</tt></i> to remove an existing
--   tooltip.
--   
--   See also <a>widgetSetTooltipText</a> and
--   <a>entrySetIconTooltipMarkup</a>.
--   
--   If you unset the widget tooltip via <a>widgetSetTooltipText</a> or
--   <a>widgetSetTooltipMarkup</a>, this sets <a>Widget:hasTooltip</a> to
--   <a>False</a>, which suppresses icon tooltips too. You can resolve this
--   by then calling <a>widgetSetHasTooltip</a> to set
--   <a>Widget:hasTooltip</a> back to <a>True</a>, or setting at least one
--   non-empty tooltip on any icon achieves the same result.
entrySetIconTooltipText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Maybe Text -> m ()

-- | Set additional hints which allow input methods to fine-tune their
--   behavior.
entrySetInputHints :: (HasCallStack, MonadIO m, IsEntry a) => a -> [InputHints] -> m ()

-- | Sets the input purpose which can be used by input methods to adjust
--   their behavior.
entrySetInputPurpose :: (HasCallStack, MonadIO m, IsEntry a) => a -> InputPurpose -> m ()

-- | Sets the character to use in place of the actual text in “password
--   mode”.
--   
--   See <a>entrySetVisibility</a> for how to enable “password mode”.
--   
--   By default, GTK picks the best invisible char available in the current
--   font. If you set the invisible char to 0, then the user will get no
--   feedback at all; there will be no text on the screen as they type.
entrySetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> Char -> m ()

-- | Sets the maximum allowed length of the contents of the widget.
--   
--   If the current contents are longer than the given length, then they
--   will be truncated to fit. The length is in characters.
--   
--   This is equivalent to getting <i><tt>entry</tt></i>'s
--   <tt>GtkEntryBuffer</tt> and calling <a>entryBufferSetMaxLength</a> on
--   it.
entrySetMaxLength :: (HasCallStack, MonadIO m, IsEntry a) => a -> Int32 -> m ()

-- | Sets the text that will be used in the context menu of the
--   <tt>GtkEntry</tt> when the specified icon is activatable. Selecting
--   this item in the menu results, from all aspects, the same than
--   clicking on the specified icon. This greatly simplifies making
--   accessible applications, because the icons aren't focusable when using
--   keyboard navigation. This is why Gtk recommends to add the same action
--   to the context menu.
--   
--   <i>Since: 4.20</i>
entrySetMenuEntryIconText :: (HasCallStack, MonadIO m, IsEntry a) => a -> EntryIconPosition -> Text -> m ()

-- | Sets whether the text is overwritten when typing in the
--   <tt>GtkEntry</tt>.
entrySetOverwriteMode :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Sets text to be displayed in <i><tt>entry</tt></i> when it is empty.
--   
--   This can be used to give a visual hint of the expected contents of the
--   <tt>GtkEntry</tt>.
entrySetPlaceholderText :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe Text -> m ()

-- | Causes the entry’s progress indicator to “fill in” the given fraction
--   of the bar.
--   
--   The fraction should be between 0.0 and 1.0, inclusive.
entrySetProgressFraction :: (HasCallStack, MonadIO m, IsEntry a) => a -> Double -> m ()

-- | Sets the fraction of total entry width to move the progress bouncing
--   block for each pulse.
--   
--   Use <a>entryProgressPulse</a> to pulse the progress.
entrySetProgressPulseStep :: (HasCallStack, MonadIO m, IsEntry a) => a -> Double -> m ()

-- | Sets a <tt>PangoTabArray</tt>.
--   
--   The tabstops in the array are applied to the entry text.
entrySetTabs :: (HasCallStack, MonadIO m, IsEntry a) => a -> Maybe TabArray -> m ()

-- | Sets whether the contents of the entry are visible or not.
--   
--   When visibility is set to <a>False</a>, characters are displayed as
--   the invisible char, and will also appear that way when the text in the
--   entry widget is copied elsewhere.
--   
--   By default, GTK picks the best invisible character available in the
--   current font, but it can be changed with <a>entrySetInvisibleChar</a>.
--   
--   Note that you probably want to set <a>Entry:inputPurpose</a> to
--   <a>InputPurposePassword</a> or <a>InputPurposePin</a> to inform input
--   methods about the purpose of this entry, in addition to setting
--   visibility to <a>False</a>.
entrySetVisibility :: (HasCallStack, MonadIO m, IsEntry a) => a -> Bool -> m ()

-- | Unsets the invisible char, so that the default invisible char is used
--   again. See <a>entrySetInvisibleChar</a>.
entryUnsetInvisibleChar :: (HasCallStack, MonadIO m, IsEntry a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activates-default</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryActivatesDefault :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #activatesDefault
--   </pre>
getEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>activates-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #activatesDefault <a>:=</a> value ]
--   </pre>
setEntryActivatesDefault :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryAttributes :: (IsEntry o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #attributes
--   </pre>
getEntryAttributes :: (MonadIO m, IsEntry o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #attributes <a>:=</a> value ]
--   </pre>
setEntryAttributes :: (MonadIO m, IsEntry o) => o -> AttrList -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buffer</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryBuffer :: (IsEntry o, MonadIO m, IsEntryBuffer a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #buffer
--   </pre>
getEntryBuffer :: (MonadIO m, IsEntry o) => o -> m EntryBuffer

-- | Set the value of the “<tt>buffer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #buffer <a>:=</a> value ]
--   </pre>
setEntryBuffer :: (MonadIO m, IsEntry o, IsEntryBuffer a) => o -> a -> m ()

-- | Set the value of the “<tt>completion</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #completion
--   </pre>
clearEntryCompletion :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>completion</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryCompletion :: (IsEntry o, MonadIO m, IsEntryCompletion a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #completion
--   </pre>
getEntryCompletion :: (MonadIO m, IsEntry o) => o -> m (Maybe EntryCompletion)

-- | Set the value of the “<tt>completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #completion <a>:=</a> value ]
--   </pre>
setEntryCompletion :: (MonadIO m, IsEntry o, IsEntryCompletion a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-emoji-completion</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryEnableEmojiCompletion :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-emoji-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #enableEmojiCompletion
--   </pre>
getEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>enable-emoji-completion</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #enableEmojiCompletion <a>:=</a> value ]
--   </pre>
setEntryEnableEmojiCompletion :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Set the value of the “<tt>extra-menu</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #extraMenu
--   </pre>
clearEntryExtraMenu :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>extra-menu</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryExtraMenu :: (IsEntry o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #extraMenu
--   </pre>
getEntryExtraMenu :: (MonadIO m, IsEntry o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>extra-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #extraMenu <a>:=</a> value ]
--   </pre>
setEntryExtraMenu :: (MonadIO m, IsEntry o, IsMenuModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryHasFrame :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #hasFrame
--   </pre>
getEntryHasFrame :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #hasFrame <a>:=</a> value ]
--   </pre>
setEntryHasFrame :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Set the value of the “<tt>im-module</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #imModule
--   </pre>
clearEntryImModule :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>im-module</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryImModule :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #imModule
--   </pre>
getEntryImModule :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>im-module</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #imModule <a>:=</a> value ]
--   </pre>
setEntryImModule :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-hints</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryInputHints :: (IsEntry o, MonadIO m) => [InputHints] -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #inputHints
--   </pre>
getEntryInputHints :: (MonadIO m, IsEntry o) => o -> m [InputHints]

-- | Set the value of the “<tt>input-hints</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #inputHints <a>:=</a> value ]
--   </pre>
setEntryInputHints :: (MonadIO m, IsEntry o) => o -> [InputHints] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>input-purpose</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEntryInputPurpose :: (IsEntry o, MonadIO m) => InputPurpose -> m (GValueConstruct o)

-- | Get the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #inputPurpose
--   </pre>
getEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> m InputPurpose

-- | Set the value of the “<tt>input-purpose</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #inputPurpose <a>:=</a> value ]
--   </pre>
setEntryInputPurpose :: (MonadIO m, IsEntry o) => o -> InputPurpose -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-char</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryInvisibleChar :: (IsEntry o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-char</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #invisibleChar
--   </pre>
getEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> m Word32

-- | Set the value of the “<tt>invisible-char</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #invisibleChar <a>:=</a> value ]
--   </pre>
setEntryInvisibleChar :: (MonadIO m, IsEntry o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invisible-char-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryInvisibleCharSet :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>invisible-char-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #invisibleCharSet
--   </pre>
getEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>invisible-char-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #invisibleCharSet <a>:=</a> value ]
--   </pre>
setEntryInvisibleCharSet :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-length</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryMaxLength :: (IsEntry o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #maxLength
--   </pre>
getEntryMaxLength :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Set the value of the “<tt>max-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #maxLength <a>:=</a> value ]
--   </pre>
setEntryMaxLength :: (MonadIO m, IsEntry o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>menu-entry-icon-primary-text</tt>” property
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #menuEntryIconPrimaryText
--   </pre>
clearEntryMenuEntryIconPrimaryText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-entry-icon-primary-text</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructEntryMenuEntryIconPrimaryText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-entry-icon-primary-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #menuEntryIconPrimaryText
--   </pre>
getEntryMenuEntryIconPrimaryText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>menu-entry-icon-primary-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #menuEntryIconPrimaryText <a>:=</a> value ]
--   </pre>
setEntryMenuEntryIconPrimaryText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Set the value of the “<tt>menu-entry-icon-secondary-text</tt>”
--   property to <a>Nothing</a>. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>clear</a> #menuEntryIconSecondaryText
--   </pre>
clearEntryMenuEntryIconSecondaryText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menu-entry-icon-secondary-text</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructEntryMenuEntryIconSecondaryText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>menu-entry-icon-secondary-text</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #menuEntryIconSecondaryText
--   </pre>
getEntryMenuEntryIconSecondaryText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>menu-entry-icon-secondary-text</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #menuEntryIconSecondaryText <a>:=</a> value ]
--   </pre>
setEntryMenuEntryIconSecondaryText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>overwrite-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryOverwriteMode :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>overwrite-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #overwriteMode
--   </pre>
getEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>overwrite-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #overwriteMode <a>:=</a> value ]
--   </pre>
setEntryOverwriteMode :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Set the value of the “<tt>placeholder-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #placeholderText
--   </pre>
clearEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>placeholder-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryPlaceholderText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #placeholderText
--   </pre>
getEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #placeholderText <a>:=</a> value ]
--   </pre>
setEntryPlaceholderText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-activatable</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconActivatable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconActivatable
--   </pre>
getEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>primary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconActivatable <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Set the value of the “<tt>primary-icon-gicon</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconGicon
--   </pre>
clearEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-gicon</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconGicon :: (IsEntry o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconGicon
--   </pre>
getEntryPrimaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>primary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconGicon <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()

-- | Set the value of the “<tt>primary-icon-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconName
--   </pre>
clearEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-name</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryPrimaryIconName :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconName
--   </pre>
getEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>primary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconName <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Set the value of the “<tt>primary-icon-paintable</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconPaintable
--   </pre>
clearEntryPrimaryIconPaintable :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-paintable</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconPaintable :: (IsEntry o, MonadIO m, IsPaintable a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconPaintable
--   </pre>
getEntryPrimaryIconPaintable :: (MonadIO m, IsEntry o) => o -> m (Maybe Paintable)

-- | Set the value of the “<tt>primary-icon-paintable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconPaintable <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconPaintable :: (MonadIO m, IsEntry o, IsPaintable a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-sensitive</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconSensitive :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconSensitive
--   </pre>
getEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>primary-icon-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconSensitive <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Get the value of the “<tt>primary-icon-storage-type</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconStorageType
--   </pre>
getEntryPrimaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType

-- | Set the value of the “<tt>primary-icon-tooltip-markup</tt>” property
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #primaryIconTooltipMarkup
--   </pre>
clearEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-tooltip-markup</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconTooltipMarkup :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-tooltip-markup</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconTooltipMarkup
--   </pre>
getEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>primary-icon-tooltip-markup</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconTooltipMarkup <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Set the value of the “<tt>primary-icon-tooltip-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #primaryIconTooltipText
--   </pre>
clearEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>primary-icon-tooltip-text</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryPrimaryIconTooltipText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>primary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #primaryIconTooltipText
--   </pre>
getEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>primary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #primaryIconTooltipText <a>:=</a> value ]
--   </pre>
setEntryPrimaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>progress-fraction</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryProgressFraction :: (IsEntry o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>progress-fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #progressFraction
--   </pre>
getEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> m Double

-- | Set the value of the “<tt>progress-fraction</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #progressFraction <a>:=</a> value ]
--   </pre>
setEntryProgressFraction :: (MonadIO m, IsEntry o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>progress-pulse-step</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryProgressPulseStep :: (IsEntry o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>progress-pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #progressPulseStep
--   </pre>
getEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> m Double

-- | Set the value of the “<tt>progress-pulse-step</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #progressPulseStep <a>:=</a> value ]
--   </pre>
setEntryProgressPulseStep :: (MonadIO m, IsEntry o) => o -> Double -> m ()

-- | Get the value of the “<tt>scroll-offset</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #scrollOffset
--   </pre>
getEntryScrollOffset :: (MonadIO m, IsEntry o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-activatable</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconActivatable :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconActivatable
--   </pre>
getEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>secondary-icon-activatable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconActivatable <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconActivatable :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Set the value of the “<tt>secondary-icon-gicon</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryIconGicon
--   </pre>
clearEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-gicon</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconGicon :: (IsEntry o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconGicon
--   </pre>
getEntrySecondaryIconGicon :: (MonadIO m, IsEntry o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>secondary-icon-gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconGicon <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconGicon :: (MonadIO m, IsEntry o, IsIcon a) => o -> a -> m ()

-- | Set the value of the “<tt>secondary-icon-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryIconName
--   </pre>
clearEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-name</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconName :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconName
--   </pre>
getEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconName <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconName :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Set the value of the “<tt>secondary-icon-paintable</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #secondaryIconPaintable
--   </pre>
clearEntrySecondaryIconPaintable :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-paintable</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconPaintable :: (IsEntry o, MonadIO m, IsPaintable a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-paintable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconPaintable
--   </pre>
getEntrySecondaryIconPaintable :: (MonadIO m, IsEntry o) => o -> m (Maybe Paintable)

-- | Set the value of the “<tt>secondary-icon-paintable</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconPaintable <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconPaintable :: (MonadIO m, IsEntry o, IsPaintable a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-sensitive</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconSensitive :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-sensitive</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconSensitive
--   </pre>
getEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>secondary-icon-sensitive</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconSensitive <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconSensitive :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Get the value of the “<tt>secondary-icon-storage-type</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconStorageType
--   </pre>
getEntrySecondaryIconStorageType :: (MonadIO m, IsEntry o) => o -> m ImageType

-- | Set the value of the “<tt>secondary-icon-tooltip-markup</tt>” property
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #secondaryIconTooltipMarkup
--   </pre>
clearEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-tooltip-markup</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructEntrySecondaryIconTooltipMarkup :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-tooltip-markup</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconTooltipMarkup
--   </pre>
getEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-icon-tooltip-markup</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconTooltipMarkup <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconTooltipMarkup :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Set the value of the “<tt>secondary-icon-tooltip-text</tt>” property
--   to <a>Nothing</a>. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>clear</a> #secondaryIconTooltipText
--   </pre>
clearEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>secondary-icon-tooltip-text</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntrySecondaryIconTooltipText :: (IsEntry o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>secondary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #secondaryIconTooltipText
--   </pre>
getEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>secondary-icon-tooltip-text</tt>” property.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #secondaryIconTooltipText <a>:=</a> value ]
--   </pre>
setEntrySecondaryIconTooltipText :: (MonadIO m, IsEntry o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-emoji-icon</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEntryShowEmojiIcon :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-emoji-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #showEmojiIcon
--   </pre>
getEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>show-emoji-icon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #showEmojiIcon <a>:=</a> value ]
--   </pre>
setEntryShowEmojiIcon :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Set the value of the “<tt>tabs</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #tabs
--   </pre>
clearEntryTabs :: (MonadIO m, IsEntry o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tabs</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEntryTabs :: (IsEntry o, MonadIO m) => TabArray -> m (GValueConstruct o)

-- | Get the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #tabs
--   </pre>
getEntryTabs :: (MonadIO m, IsEntry o) => o -> m (Maybe TabArray)

-- | Set the value of the “<tt>tabs</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #tabs <a>:=</a> value ]
--   </pre>
setEntryTabs :: (MonadIO m, IsEntry o) => o -> TabArray -> m ()

-- | Get the value of the “<tt>text-length</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #textLength
--   </pre>
getEntryTextLength :: (MonadIO m, IsEntry o) => o -> m Word32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>truncate-multiline</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructEntryTruncateMultiline :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>truncate-multiline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #truncateMultiline
--   </pre>
getEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>truncate-multiline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #truncateMultiline <a>:=</a> value ]
--   </pre>
setEntryTruncateMultiline :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visibility</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEntryVisibility :: (IsEntry o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visibility</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> entry #visibility
--   </pre>
getEntryVisibility :: (MonadIO m, IsEntry o) => o -> m Bool

-- | Set the value of the “<tt>visibility</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> entry [ #visibility <a>:=</a> value ]
--   </pre>
setEntryVisibility :: (MonadIO m, IsEntry o) => o -> Bool -> m ()

-- | Emitted when the entry is activated.
--   
--   The keybindings for this signal are all forms of the Enter key.
type EntryActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryActivate :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #activate callback
--   </pre>
onEntryActivate :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryActivateCallback) -> m SignalHandlerId

-- | Emitted when an activatable icon is clicked.
type EntryIconPressCallback = EntryIconPosition -> IO ()

-- | Connect a signal handler for the <a>iconPress</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #iconPress callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryIconPress :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconPressCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>iconPress</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #iconPress callback
--   </pre>
onEntryIconPress :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconPressCallback) -> m SignalHandlerId

-- | Emitted on the button release from a mouse click over an activatable
--   icon.
type EntryIconReleaseCallback = EntryIconPosition -> IO ()

-- | Connect a signal handler for the <a>iconRelease</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> entry #iconRelease callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEntryIconRelease :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconReleaseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>iconRelease</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> entry #iconRelease callback
--   </pre>
onEntryIconRelease :: (IsEntry a, MonadIO m) => a -> ((?self :: a) => EntryIconReleaseCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Entry.Entry
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Entry.Entry
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Entry.Entry
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Entry.Entry o) => GI.Gtk.Objects.Entry.IsEntry o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Entry.Entry)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Entry.Entry
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Entry.Entry


-- | Used by text widgets to let users insert Emoji characters.
--   
--   &lt;picture&gt; &lt;source srcset="emojichooser-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkEmojiChooser" src="emojichooser.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkEmojiChooser</tt> emits the <a>EmojiChooser::emojiPicked</a>
--   signal when an Emoji is selected.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkEmojiChooser</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;N&lt;/kbd&gt; scrolls th
--   the next section.</li>
--   <li>&lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;P&lt;/kbd&gt; scrolls th
--   the previous section.</li>
--   </ul>
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkEmojiChooser</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>scroll.section</tt> scrolls to the next or previous
--   section.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   popover
--   ├── box.emoji-searchbar
--   │   ╰── entry.search
--   ╰── box.emoji-toolbar
--       ├── button.image-button.emoji-section
--       ├── ...
--       ╰── button.image-button.emoji-section
--   </pre>
--   
--   Every <tt>GtkEmojiChooser</tt> consists of a main node called popover.
--   The contents of the popover are largely implementation defined and
--   supposed to inherit general styles. The top searchbar used to search
--   emoji and gets the .emoji-searchbar style class itself. The bottom
--   toolbar used to switch between different emoji categories consists of
--   buttons with the .emoji-section style class and gets the
--   .emoji-toolbar style class itself.
module GI.Gtk.Objects.EmojiChooser

-- | Memory-managed wrapper type.
newtype EmojiChooser
EmojiChooser :: ManagedPtr EmojiChooser -> EmojiChooser

-- | Type class for types which can be safely cast to <a>EmojiChooser</a>,
--   for instance with <a>toEmojiChooser</a>.
class (GObject o, IsDescendantOf EmojiChooser o) => IsEmojiChooser o

-- | Cast to <a>EmojiChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toEmojiChooser :: (MonadIO m, IsEmojiChooser o) => o -> m EmojiChooser

-- | Creates a new <tt>GtkEmojiChooser</tt>.
emojiChooserNew :: (HasCallStack, MonadIO m) => m EmojiChooser

-- | Emitted when the user selects an Emoji.
type EmojiChooserEmojiPickedCallback = Text -> IO ()

-- | Connect a signal handler for the <a>emojiPicked</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> emojiChooser #emojiPicked callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEmojiChooserEmojiPicked :: (IsEmojiChooser a, MonadIO m) => a -> ((?self :: a) => EmojiChooserEmojiPickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>emojiPicked</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> emojiChooser #emojiPicked callback
--   </pre>
onEmojiChooserEmojiPicked :: (IsEmojiChooser a, MonadIO m) => a -> ((?self :: a) => EmojiChooserEmojiPickedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.EmojiChooser.EmojiChooser
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EmojiChooser.EmojiChooser
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EmojiChooser.EmojiChooser
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EmojiChooser.EmojiChooser o) => GI.Gtk.Objects.EmojiChooser.IsEmojiChooser o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EmojiChooser.EmojiChooser)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EmojiChooser.EmojiChooser
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EmojiChooser.EmojiChooser


-- | Allows users to edit the displayed text by switching to an “edit
--   mode”.
--   
--   &lt;picture&gt; &lt;source srcset="editable-label-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkEditableLabel" src="editable-label.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkEditableLabel</tt> does not have API of its own, but it
--   implements the <a>Editable</a> interface.
--   
--   The default bindings for activating the edit mode is to click or press
--   the Enter key. The default bindings for leaving the edit mode are the
--   Enter key (to save the results) or the Escape key (to cancel the
--   editing).
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkEditableLabel</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Enter&lt;/kbd&gt; starts editing.</li>
--   <li>&lt;kbd&gt;Escape&lt;/kbd&gt; stops editing.</li>
--   </ul>
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkEditableLabel</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>editing.starts</tt> switches the widget into editing
--   mode.</li>
--   <li><tt>editing.stop</tt> switches the widget out of editing
--   mode.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   editablelabel[.editing]
--   ╰── stack
--       ├── label
--       ╰── text
--   </pre>
--   
--   <tt>GtkEditableLabel</tt> has a main node with the name editablelabel.
--   When the entry is in editing mode, it gets the .editing style class.
--   
--   For all the subnodes added to the text node in various situations, see
--   <a>Text</a>.
module GI.Gtk.Objects.EditableLabel

-- | Memory-managed wrapper type.
newtype EditableLabel
EditableLabel :: ManagedPtr EditableLabel -> EditableLabel

-- | Type class for types which can be safely cast to <a>EditableLabel</a>,
--   for instance with <a>toEditableLabel</a>.
class (GObject o, IsDescendantOf EditableLabel o) => IsEditableLabel o

-- | Cast to <a>EditableLabel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toEditableLabel :: (MonadIO m, IsEditableLabel o) => o -> m EditableLabel

-- | Returns whether the label is currently in “editing mode”.
editableLabelGetEditing :: (HasCallStack, MonadIO m, IsEditableLabel a) => a -> m Bool

-- | Creates a new <tt>GtkEditableLabel</tt> widget.
editableLabelNew :: (HasCallStack, MonadIO m) => Text -> m EditableLabel

-- | Switches the label into “editing mode”.
editableLabelStartEditing :: (HasCallStack, MonadIO m, IsEditableLabel a) => a -> m ()

-- | Switches the label out of “editing mode”.
--   
--   If <i><tt>commit</tt></i> is <a>True</a>, the resulting text is kept
--   as the <a>Editable:text</a> property value, otherwise the resulting
--   text is discarded and the label will keep its previous
--   <a>Editable:text</a> property value.
editableLabelStopEditing :: (HasCallStack, MonadIO m, IsEditableLabel a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEditableLabelEditing :: (IsEditableLabel o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editableLabel #editing
--   </pre>
getEditableLabelEditing :: (MonadIO m, IsEditableLabel o) => o -> m Bool

-- | Set the value of the “<tt>editing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> editableLabel [ #editing <a>:=</a> value ]
--   </pre>
setEditableLabelEditing :: (MonadIO m, IsEditableLabel o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.EditableLabel.EditableLabel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.EditableLabel.EditableLabel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.EditableLabel.EditableLabel
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.EditableLabel.EditableLabel o) => GI.Gtk.Objects.EditableLabel.IsEditableLabel o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.EditableLabel.EditableLabel)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.EditableLabel.EditableLabel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.EditableLabel.EditableLabel


-- | An event controller to receive Drag-and-Drop operations,
--   asynchronously.
--   
--   It is the more complete but also more complex method of handling drop
--   operations compared to <a>DropTarget</a>, and you should only use it
--   if <tt>GtkDropTarget</tt> doesn't provide all the features you need.
--   
--   To use a <tt>GtkDropTargetAsync</tt> to receive drops on a widget, you
--   create a <tt>GtkDropTargetAsync</tt> object, configure which data
--   formats and actions you support, connect to its signals, and then
--   attach it to the widget with <a>widgetAddController</a>.
--   
--   During a drag operation, the first signal that a
--   <tt>GtkDropTargetAsync</tt> emits is <a>DropTargetAsync::accept</a>,
--   which is meant to determine whether the target is a possible drop site
--   for the ongoing drop. The default handler for the <a>accept</a> signal
--   accepts the drop if it finds a compatible data format and an action
--   that is supported on both sides.
--   
--   If it is, and the widget becomes a target, you will receive a
--   <a>DropTargetAsync::dragEnter</a> signal, followed by
--   <a>DropTargetAsync::dragMotion</a> signals as the pointer moves,
--   optionally a <a>DropTargetAsync::drop</a> signal when a drop happens,
--   and finally a <a>DropTargetAsync::dragLeave</a> signal when the
--   pointer moves off the widget.
--   
--   The <a>dragEnter</a> and <a>dragMotion</a> handler return a
--   <tt>GdkDragAction</tt> to update the status of the ongoing operation.
--   The <a>drop</a> handler should decide if it ultimately accepts the
--   drop and if it does, it should initiate the data transfer and finish
--   the operation by calling <a>dropFinish</a>.
--   
--   Between the <a>dragEnter</a> and <a>dragLeave</a> signals the widget
--   is a current drop target, and will receive the
--   <a>StateFlagsDropActive</a> state, which can be used by themes to
--   style the widget as a drop target.
module GI.Gtk.Objects.DropTargetAsync

-- | Memory-managed wrapper type.
newtype DropTargetAsync
DropTargetAsync :: ManagedPtr DropTargetAsync -> DropTargetAsync

-- | Type class for types which can be safely cast to
--   <a>DropTargetAsync</a>, for instance with <a>toDropTargetAsync</a>.
class (GObject o, IsDescendantOf DropTargetAsync o) => IsDropTargetAsync o

-- | Cast to <a>DropTargetAsync</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toDropTargetAsync :: (MonadIO m, IsDropTargetAsync o) => o -> m DropTargetAsync

-- | Gets the actions that this drop target supports.
dropTargetAsyncGetActions :: (HasCallStack, MonadIO m, IsDropTargetAsync a) => a -> m [DragAction]

-- | Gets the data formats that this drop target accepts.
--   
--   If the result is <a>Nothing</a>, all formats are expected to be
--   supported.
dropTargetAsyncGetFormats :: (HasCallStack, MonadIO m, IsDropTargetAsync a) => a -> m (Maybe ContentFormats)

-- | Creates a new <tt>GtkDropTargetAsync</tt> object.
dropTargetAsyncNew :: (HasCallStack, MonadIO m) => Maybe ContentFormats -> [DragAction] -> m DropTargetAsync

-- | Sets the <i><tt>drop</tt></i> as not accepted on this drag site.
--   
--   This function should be used when delaying the decision on whether to
--   accept a drag or not until after reading the data.
dropTargetAsyncRejectDrop :: (HasCallStack, MonadIO m, IsDropTargetAsync a, IsDrop b) => a -> b -> m ()

-- | Sets the actions that this drop target supports.
dropTargetAsyncSetActions :: (HasCallStack, MonadIO m, IsDropTargetAsync a) => a -> [DragAction] -> m ()

-- | Sets the data formats that this drop target will accept.
dropTargetAsyncSetFormats :: (HasCallStack, MonadIO m, IsDropTargetAsync a) => a -> Maybe ContentFormats -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>actions</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDropTargetAsyncActions :: (IsDropTargetAsync o, MonadIO m) => [DragAction] -> m (GValueConstruct o)

-- | Get the value of the “<tt>actions</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTargetAsync #actions
--   </pre>
getDropTargetAsyncActions :: (MonadIO m, IsDropTargetAsync o) => o -> m [DragAction]

-- | Set the value of the “<tt>actions</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropTargetAsync [ #actions <a>:=</a> value ]
--   </pre>
setDropTargetAsyncActions :: (MonadIO m, IsDropTargetAsync o) => o -> [DragAction] -> m ()

-- | Set the value of the “<tt>formats</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #formats
--   </pre>
clearDropTargetAsyncFormats :: (MonadIO m, IsDropTargetAsync o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>formats</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDropTargetAsyncFormats :: (IsDropTargetAsync o, MonadIO m) => ContentFormats -> m (GValueConstruct o)

-- | Get the value of the “<tt>formats</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTargetAsync #formats
--   </pre>
getDropTargetAsyncFormats :: (MonadIO m, IsDropTargetAsync o) => o -> m (Maybe ContentFormats)

-- | Set the value of the “<tt>formats</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropTargetAsync [ #formats <a>:=</a> value ]
--   </pre>
setDropTargetAsyncFormats :: (MonadIO m, IsDropTargetAsync o) => o -> ContentFormats -> m ()

-- | Emitted on the drop site when a drop operation is about to begin.
--   
--   If the drop is not accepted, <a>False</a> will be returned and the
--   drop target will ignore the drop. If <a>True</a> is returned, the drop
--   is accepted for now but may be rejected later via a call to
--   <a>dropTargetAsyncRejectDrop</a> or ultimately by returning
--   <a>False</a> from a <a>DropTargetAsync::drop</a> handler.
--   
--   The default handler for this signal decides whether to accept the drop
--   based on the formats provided by the <i><tt>drop</tt></i>.
--   
--   If the decision whether the drop will be accepted or rejected needs
--   further processing, such as inspecting the data, this function should
--   return <a>True</a> and proceed as is <i><tt>drop</tt></i> was accepted
--   and if it decides to reject the drop later, it should call
--   <a>dropTargetAsyncRejectDrop</a>.
type DropTargetAsyncAcceptCallback = Drop -> IO Bool

-- | Connect a signal handler for the <a>accept</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTargetAsync #accept callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetAsyncAccept :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncAcceptCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accept</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropTargetAsync #accept callback
--   </pre>
onDropTargetAsyncAccept :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncAcceptCallback) -> m SignalHandlerId

-- | Emitted on the drop site when the pointer enters the widget.
--   
--   It can be used to set up custom highlighting.
type DropTargetAsyncDragEnterCallback = Drop -> Double -> Double -> IO [DragAction]

-- | Connect a signal handler for the <a>dragEnter</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTargetAsync #dragEnter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetAsyncDragEnter :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragEnter</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropTargetAsync #dragEnter callback
--   </pre>
onDropTargetAsyncDragEnter :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragEnterCallback) -> m SignalHandlerId

-- | Emitted on the drop site when the pointer leaves the widget.
--   
--   Its main purpose it to undo things done in
--   <tt>GtkDropTargetAsync</tt><a>dragEnter</a>.
type DropTargetAsyncDragLeaveCallback = Drop -> IO ()

-- | Connect a signal handler for the <a>dragLeave</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTargetAsync #dragLeave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetAsyncDragLeave :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragLeave</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropTargetAsync #dragLeave callback
--   </pre>
onDropTargetAsyncDragLeave :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragLeaveCallback) -> m SignalHandlerId

-- | Emitted while the pointer is moving over the drop target.
type DropTargetAsyncDragMotionCallback = Drop -> Double -> Double -> IO [DragAction]

-- | Connect a signal handler for the <a>dragMotion</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTargetAsync #dragMotion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetAsyncDragMotion :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragMotion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropTargetAsync #dragMotion callback
--   </pre>
onDropTargetAsyncDragMotion :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragMotionCallback) -> m SignalHandlerId

-- | Emitted on the drop site when the user drops the data onto the widget.
--   
--   The signal handler must determine whether the pointer position is in a
--   drop zone or not. If it is not in a drop zone, it returns <a>False</a>
--   and no further processing is necessary.
--   
--   Otherwise, the handler returns <a>True</a>. In this case, this handler
--   will accept the drop. The handler must ensure that <a>dropFinish</a>
--   is called to let the source know that the drop is done. The call to
--   <a>dropFinish</a> must only be done when all data has been received.
--   
--   To receive the data, use one of the read functions provided by
--   <a>Drop</a> such as <a>dropReadAsync</a> or <a>dropReadValueAsync</a>.
type DropTargetAsyncDropCallback = Drop -> Double -> Double -> IO Bool

-- | Connect a signal handler for the <a>drop</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTargetAsync #drop callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetAsyncDrop :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>drop</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dropTargetAsync #drop callback
--   </pre>
onDropTargetAsyncDrop :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDropCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.DropTargetAsync.DropTargetAsync
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DropTargetAsync.DropTargetAsync
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DropTargetAsync.DropTargetAsync
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DropTargetAsync.DropTargetAsync o) => GI.Gtk.Objects.DropTargetAsync.IsDropTargetAsync o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DropTargetAsync.DropTargetAsync)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DropTargetAsync.DropTargetAsync
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DropTargetAsync.DropTargetAsync


-- | An event controller to receive Drag-and-Drop operations.
--   
--   The most basic way to use a <tt>GtkDropTarget</tt> to receive drops on
--   a widget is to create it via <a>dropTargetNew</a>, passing in the
--   <tt>GType</tt> of the data you want to receive and connect to the
--   <a>DropTarget::drop</a> signal to receive the data:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static gboolean
--   on_drop (GtkDropTarget *target,
--            const GValue  *value,
--            double         x,
--            double         y,
--            gpointer       data)
--   {
--     MyWidget *self = data;
--   
--     // Call the appropriate setter depending on the type of data
--     // that we received
--     if (G_VALUE_HOLDS (value, G_TYPE_FILE))
--       my_widget_set_file (self, g_value_get_object (value));
--     else if (G_VALUE_HOLDS (value, GDK_TYPE_PIXBUF))
--       my_widget_set_pixbuf (self, g_value_get_object (value));
--     else
--       return FALSE;
--   
--     return TRUE;
--   }
--   
--   static void
--   my_widget_init (MyWidget *self)
--   {
--     GtkDropTarget *target =
--       gtk_drop_target_new (G_TYPE_INVALID, GDK_ACTION_COPY);
--   
--     // This widget accepts two types of drop types: GFile objects
--     // and GdkPixbuf objects
--     gtk_drop_target_set_gtypes (target, (GType [2]) {
--       G_TYPE_FILE,
--       GDK_TYPE_PIXBUF,
--     }, 2);
--   
--     g_signal_connect (target, "drop", G_CALLBACK (on_drop), self);
--     gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (target));
--   }
--   </pre>
--   
--   <tt>GtkDropTarget</tt> supports more options, such as:
--   
--   <ul>
--   <li>rejecting potential drops via the <a>DropTarget::accept</a> signal
--   and the <a>dropTargetReject</a> function to let other drop targets
--   handle the drop</li>
--   <li>tracking an ongoing drag operation before the drop via the
--   <a>DropTarget::enter</a>, <a>DropTarget::motion</a> and
--   <a>DropTarget::leave</a> signals</li>
--   <li>configuring how to receive data by setting the
--   <a>DropTarget:preload</a> property and listening for its availability
--   via the <a>DropTarget:value</a> property</li>
--   </ul>
--   
--   However, <tt>GtkDropTarget</tt> is ultimately modeled in a synchronous
--   way and only supports data transferred via <tt>GType</tt>. If you want
--   full control over an ongoing drop, the <a>DropTargetAsync</a> object
--   gives you this ability.
--   
--   While a pointer is dragged over the drop target's widget and the drop
--   has not been rejected, that widget will receive the
--   <a>StateFlagsDropActive</a> state, which can be used to style the
--   widget.
--   
--   If you are not interested in receiving the drop, but just want to
--   update UI state during a Drag-and-Drop operation (e.g. switching
--   tabs), you can use <a>DropControllerMotion</a>.
module GI.Gtk.Objects.DropTarget

-- | Memory-managed wrapper type.
newtype DropTarget
DropTarget :: ManagedPtr DropTarget -> DropTarget

-- | Type class for types which can be safely cast to <a>DropTarget</a>,
--   for instance with <a>toDropTarget</a>.
class (GObject o, IsDescendantOf DropTarget o) => IsDropTarget o

-- | Cast to <a>DropTarget</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDropTarget :: (MonadIO m, IsDropTarget o) => o -> m DropTarget

-- | Gets the actions that this drop target supports.
dropTargetGetActions :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m [DragAction]

-- | Gets the currently handled drop operation.
--   
--   If no drop operation is going on, <a>Nothing</a> is returned.
--   
--   <i>Since: 4.4</i>
dropTargetGetCurrentDrop :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m (Maybe Drop)

-- | Gets the currently handled drop operation.
--   
--   If no drop operation is going on, <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.4)Use <a>dropTargetGetCurrentDrop</a>
--   instead</i>
dropTargetGetDrop :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m (Maybe Drop)

-- | Gets the data formats that this drop target accepts.
--   
--   If the result is <a>Nothing</a>, all formats are expected to be
--   supported.
dropTargetGetFormats :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m (Maybe ContentFormats)

-- | Gets the list of supported <tt>GType</tt>s that can be dropped on the
--   target.
--   
--   If no types have been set, <tt>NULL</tt> will be returned.
dropTargetGetGtypes :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m (Maybe [GType])

-- | Gets whether data should be preloaded on hover.
dropTargetGetPreload :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m Bool

-- | Gets the current drop data, as a <tt>GValue</tt>.
dropTargetGetValue :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m (Maybe GValue)

-- | Creates a new <tt>GtkDropTarget</tt> object.
--   
--   If the drop target should support more than 1 type, pass
--   <tt><i>G_TYPE_INVALID</i></tt> for <i><tt>type</tt></i> and then call
--   <a>dropTargetSetGtypes</a>.
dropTargetNew :: (HasCallStack, MonadIO m) => GType -> [DragAction] -> m DropTarget

-- | Rejects the ongoing drop operation.
--   
--   If no drop operation is ongoing, i.e when
--   <a>DropTarget:currentDrop</a> is <a>Nothing</a>, this function does
--   nothing.
--   
--   This function should be used when delaying the decision on whether to
--   accept a drag or not until after reading the data.
dropTargetReject :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> m ()

-- | Sets the actions that this drop target supports.
dropTargetSetActions :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> [DragAction] -> m ()

-- | Sets the supported <tt>GType</tt>s for this drop target.
dropTargetSetGtypes :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> Maybe [GType] -> m ()

-- | Sets whether data should be preloaded on hover.
dropTargetSetPreload :: (HasCallStack, MonadIO m, IsDropTarget a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>actions</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDropTargetActions :: (IsDropTarget o, MonadIO m) => [DragAction] -> m (GValueConstruct o)

-- | Get the value of the “<tt>actions</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTarget #actions
--   </pre>
getDropTargetActions :: (MonadIO m, IsDropTarget o) => o -> m [DragAction]

-- | Set the value of the “<tt>actions</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropTarget [ #actions <a>:=</a> value ]
--   </pre>
setDropTargetActions :: (MonadIO m, IsDropTarget o) => o -> [DragAction] -> m ()

-- | Get the value of the “<tt>current-drop</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTarget #currentDrop
--   </pre>
getDropTargetCurrentDrop :: (MonadIO m, IsDropTarget o) => o -> m (Maybe Drop)

-- | Get the value of the “<tt>drop</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTarget #drop
--   </pre>
getDropTargetDrop :: (MonadIO m, IsDropTarget o) => o -> m (Maybe Drop)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>formats</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDropTargetFormats :: (IsDropTarget o, MonadIO m) => ContentFormats -> m (GValueConstruct o)

-- | Get the value of the “<tt>formats</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTarget #formats
--   </pre>
getDropTargetFormats :: (MonadIO m, IsDropTarget o) => o -> m (Maybe ContentFormats)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>preload</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDropTargetPreload :: (IsDropTarget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>preload</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTarget #preload
--   </pre>
getDropTargetPreload :: (MonadIO m, IsDropTarget o) => o -> m Bool

-- | Set the value of the “<tt>preload</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropTarget [ #preload <a>:=</a> value ]
--   </pre>
setDropTargetPreload :: (MonadIO m, IsDropTarget o) => o -> Bool -> m ()

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropTarget #value
--   </pre>
getDropTargetValue :: (MonadIO m, IsDropTarget o) => o -> m (Maybe GValue)

-- | Emitted on the drop site when a drop operation is about to begin.
--   
--   If the drop is not accepted, <a>False</a> will be returned and the
--   drop target will ignore the drop. If <a>True</a> is returned, the drop
--   is accepted for now but may be rejected later via a call to
--   <a>dropTargetReject</a> or ultimately by returning <a>False</a> from a
--   <a>DropTarget::drop</a> handler.
--   
--   The default handler for this signal decides whether to accept the drop
--   based on the formats provided by the <i><tt>drop</tt></i>.
--   
--   If the decision whether the drop will be accepted or rejected depends
--   on the data, this function should return <a>True</a>, the
--   <a>DropTarget:preload</a> property should be set and the value should
--   be inspected via the <a>notify</a>:value signal, calling
--   <a>dropTargetReject</a> if required.
type DropTargetAcceptCallback = Drop -> IO Bool

-- | Connect a signal handler for the <a>accept</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTarget #accept callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetAccept :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetAcceptCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accept</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropTarget #accept callback
--   </pre>
onDropTargetAccept :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetAcceptCallback) -> m SignalHandlerId

-- | Emitted on the drop site when the user drops the data onto the widget.
--   
--   The signal handler must determine whether the pointer position is in a
--   drop zone or not. If it is not in a drop zone, it returns <a>False</a>
--   and no further processing is necessary.
--   
--   Otherwise, the handler returns <a>True</a>. In this case, this handler
--   will accept the drop. The handler is responsible for using the given
--   <i><tt>value</tt></i> and performing the drop operation.
type DropTargetDropCallback = GValue -> Double -> Double -> IO Bool

-- | Connect a signal handler for the <a>drop</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTarget #drop callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetDrop :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetDropCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>drop</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dropTarget #drop callback
--   </pre>
onDropTargetDrop :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetDropCallback) -> m SignalHandlerId

-- | Emitted on the drop site when the pointer enters the widget.
--   
--   It can be used to set up custom highlighting.
type DropTargetEnterCallback = Double -> Double -> IO [DragAction]

-- | Connect a signal handler for the <a>enter</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTarget #enter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetEnter :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enter</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dropTarget #enter callback
--   </pre>
onDropTargetEnter :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetEnterCallback) -> m SignalHandlerId

-- | Emitted on the drop site when the pointer leaves the widget.
--   
--   Its main purpose it to undo things done in <a>DropTarget::enter</a>.
type DropTargetLeaveCallback = IO ()

-- | Connect a signal handler for the <a>leave</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTarget #leave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetLeave :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dropTarget #leave callback
--   </pre>
onDropTargetLeave :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetLeaveCallback) -> m SignalHandlerId

-- | Emitted while the pointer is moving over the drop target.
type DropTargetMotionCallback = Double -> Double -> IO [DragAction]

-- | Connect a signal handler for the <a>motion</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropTarget #motion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropTargetMotion :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropTarget #motion callback
--   </pre>
onDropTargetMotion :: (IsDropTarget a, MonadIO m) => a -> ((?self :: a) => DropTargetMotionCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.DropTarget.DropTarget
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DropTarget.DropTarget
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DropTarget.DropTarget
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DropTarget.DropTarget o) => GI.Gtk.Objects.DropTarget.IsDropTarget o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DropTarget.DropTarget)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DropTarget.DropTarget
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DropTarget.DropTarget


-- | Allows the user to choose an item from a list of options.
--   
--   &lt;picture&gt; &lt;source srcset="drop-down-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkDropDown" src="drop-down.png"&gt; &lt;/picture&gt;
--   
--   The <tt>GtkDropDown</tt> displays the
--   [selected]<a>DropDown:selected</a> choice.
--   
--   The options are given to <tt>GtkDropDown</tt> in the form of
--   <tt>GListModel</tt> and how the individual options are represented is
--   determined by a <a>ListItemFactory</a>. The default factory displays
--   simple strings, and adds a checkmark to the selected item in the
--   popup.
--   
--   To set your own factory, use <a>dropDownSetFactory</a>. It is possible
--   to use a separate factory for the items in the popup, with
--   <a>dropDownSetListFactory</a>.
--   
--   <tt>GtkDropDown</tt> knows how to obtain strings from the items in a
--   <a>StringList</a>; for other models, you have to provide an expression
--   to find the strings via <a>dropDownSetExpression</a>.
--   
--   <tt>GtkDropDown</tt> can optionally allow search in the popup, which
--   is useful if the list of options is long. To enable the search entry,
--   use <a>dropDownSetEnableSearch</a>.
--   
--   Here is a UI definition example for <tt>GtkDropDown</tt> with a simple
--   model:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkDropDown"&gt;
--     &lt;property name="model"&gt;
--       &lt;object class="GtkStringList"&gt;
--         &lt;items&gt;
--           &lt;item translatable="yes"&gt;Factory&lt;/item&gt;
--           &lt;item translatable="yes"&gt;Home&lt;/item&gt;
--           &lt;item translatable="yes"&gt;Subway&lt;/item&gt;
--         &lt;/items&gt;
--       &lt;/object&gt;
--     &lt;/property&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   If a <tt>GtkDropDown</tt> is created in this manner, or with
--   <a>dropDownNewFromStrings</a>, for instance, the object returned from
--   <a>dropDownGetSelectedItem</a> will be a <a>StringObject</a>.
--   
--   To learn more about the list widget framework, see the
--   <a>overview</a>.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkDropDown</tt> has a single CSS node with name dropdown, with
--   the button and popover nodes as children.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkDropDown</tt> uses the <a>AccessibleRoleComboBox</a> role.
module GI.Gtk.Objects.DropDown

-- | Memory-managed wrapper type.
newtype DropDown
DropDown :: ManagedPtr DropDown -> DropDown

-- | Type class for types which can be safely cast to <a>DropDown</a>, for
--   instance with <a>toDropDown</a>.
class (GObject o, IsDescendantOf DropDown o) => IsDropDown o

-- | Cast to <a>DropDown</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toDropDown :: (MonadIO m, IsDropDown o) => o -> m DropDown

-- | Returns whether search is enabled.
dropDownGetEnableSearch :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m Bool

-- | Gets the expression set that is used to obtain strings from items.
--   
--   See <a>dropDownSetExpression</a>.
dropDownGetExpression :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m (Maybe Expression)

-- | Gets the factory that's currently used to populate list items.
--   
--   The factory returned by this function is always used for the item in
--   the button. It is also used for items in the popup if
--   <a>DropDown:listFactory</a> is not set.
dropDownGetFactory :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m (Maybe ListItemFactory)

-- | Gets the factory that's currently used to create header widgets for
--   the popup.
--   
--   <i>Since: 4.12</i>
dropDownGetHeaderFactory :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m (Maybe ListItemFactory)

-- | Gets the factory that's currently used to populate list items in the
--   popup.
dropDownGetListFactory :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m (Maybe ListItemFactory)

-- | Gets the model that provides the displayed items.
dropDownGetModel :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m (Maybe ListModel)

-- | Returns the match mode that the search filter is using.
--   
--   <i>Since: 4.12</i>
dropDownGetSearchMatchMode :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m StringFilterMatchMode

-- | Gets the position of the selected item.
dropDownGetSelected :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m Word32

-- | Gets the selected item. If no item is selected, <a>Nothing</a> is
--   returned.
dropDownGetSelectedItem :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m (Maybe Object)

-- | Returns whether to show an arrow within the widget.
--   
--   <i>Since: 4.6</i>
dropDownGetShowArrow :: (HasCallStack, MonadIO m, IsDropDown a) => a -> m Bool

-- | Creates a new <tt>GtkDropDown</tt>.
--   
--   You may want to call <a>dropDownSetFactory</a> to set up a way to map
--   its items to widgets.
dropDownNew :: (HasCallStack, MonadIO m, IsListModel a, IsExpression b) => Maybe a -> Maybe b -> m DropDown

-- | Creates a new <tt>GtkDropDown</tt> that is populated with the strings.
dropDownNewFromStrings :: (HasCallStack, MonadIO m) => [Text] -> m DropDown

-- | Sets whether a search entry will be shown in the popup that allows to
--   search for items in the list.
--   
--   Note that <a>DropDown:expression</a> must be set for search to work.
dropDownSetEnableSearch :: (HasCallStack, MonadIO m, IsDropDown a) => a -> Bool -> m ()

-- | Sets the expression that gets evaluated to obtain strings from items.
--   
--   This is used for search in the popup. The expression must have a value
--   type of <tt><i>G_TYPE_STRING</i></tt>.
dropDownSetExpression :: (HasCallStack, MonadIO m, IsDropDown a, IsExpression b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkListItemFactory</tt> to use for populating list items.
dropDownSetFactory :: (HasCallStack, MonadIO m, IsDropDown a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkListItemFactory</tt> to use for creating header
--   widgets for the popup.
--   
--   <i>Since: 4.12</i>
dropDownSetHeaderFactory :: (HasCallStack, MonadIO m, IsDropDown a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkListItemFactory</tt> to use for populating list items
--   in the popup.
dropDownSetListFactory :: (HasCallStack, MonadIO m, IsDropDown a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the <tt>GListModel</tt> to use.
dropDownSetModel :: (HasCallStack, MonadIO m, IsDropDown a, IsListModel b) => a -> Maybe b -> m ()

-- | Sets the match mode for the search filter.
--   
--   <i>Since: 4.12</i>
dropDownSetSearchMatchMode :: (HasCallStack, MonadIO m, IsDropDown a) => a -> StringFilterMatchMode -> m ()

-- | Selects the item at the given position.
dropDownSetSelected :: (HasCallStack, MonadIO m, IsDropDown a) => a -> Word32 -> m ()

-- | Sets whether an arrow will be displayed within the widget.
--   
--   <i>Since: 4.6</i>
dropDownSetShowArrow :: (HasCallStack, MonadIO m, IsDropDown a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-search</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructDropDownEnableSearch :: (IsDropDown o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #enableSearch
--   </pre>
getDropDownEnableSearch :: (MonadIO m, IsDropDown o) => o -> m Bool

-- | Set the value of the “<tt>enable-search</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #enableSearch <a>:=</a> value ]
--   </pre>
setDropDownEnableSearch :: (MonadIO m, IsDropDown o) => o -> Bool -> m ()

-- | Set the value of the “<tt>expression</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #expression
--   </pre>
clearDropDownExpression :: (MonadIO m, IsDropDown o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expression</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDropDownExpression :: (IsDropDown o, MonadIO m, IsExpression a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #expression
--   </pre>
getDropDownExpression :: (MonadIO m, IsDropDown o) => o -> m (Maybe Expression)

-- | Set the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #expression <a>:=</a> value ]
--   </pre>
setDropDownExpression :: (MonadIO m, IsDropDown o, IsExpression a) => o -> a -> m ()

-- | Set the value of the “<tt>factory</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #factory
--   </pre>
clearDropDownFactory :: (MonadIO m, IsDropDown o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>factory</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDropDownFactory :: (IsDropDown o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #factory
--   </pre>
getDropDownFactory :: (MonadIO m, IsDropDown o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #factory <a>:=</a> value ]
--   </pre>
setDropDownFactory :: (MonadIO m, IsDropDown o, IsListItemFactory a) => o -> a -> m ()

-- | Set the value of the “<tt>header-factory</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #headerFactory
--   </pre>
clearDropDownHeaderFactory :: (MonadIO m, IsDropDown o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>header-factory</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDropDownHeaderFactory :: (IsDropDown o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>header-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #headerFactory
--   </pre>
getDropDownHeaderFactory :: (MonadIO m, IsDropDown o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>header-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #headerFactory <a>:=</a> value ]
--   </pre>
setDropDownHeaderFactory :: (MonadIO m, IsDropDown o, IsListItemFactory a) => o -> a -> m ()

-- | Set the value of the “<tt>list-factory</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #listFactory
--   </pre>
clearDropDownListFactory :: (MonadIO m, IsDropDown o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>list-factory</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructDropDownListFactory :: (IsDropDown o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>list-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #listFactory
--   </pre>
getDropDownListFactory :: (MonadIO m, IsDropDown o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>list-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #listFactory <a>:=</a> value ]
--   </pre>
setDropDownListFactory :: (MonadIO m, IsDropDown o, IsListItemFactory a) => o -> a -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearDropDownModel :: (MonadIO m, IsDropDown o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDropDownModel :: (IsDropDown o, MonadIO m, IsListModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #model
--   </pre>
getDropDownModel :: (MonadIO m, IsDropDown o) => o -> m (Maybe ListModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #model <a>:=</a> value ]
--   </pre>
setDropDownModel :: (MonadIO m, IsDropDown o, IsListModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>search-match-mode</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDropDownSearchMatchMode :: (IsDropDown o, MonadIO m) => StringFilterMatchMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>search-match-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #searchMatchMode
--   </pre>
getDropDownSearchMatchMode :: (MonadIO m, IsDropDown o) => o -> m StringFilterMatchMode

-- | Set the value of the “<tt>search-match-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #searchMatchMode <a>:=</a> value ]
--   </pre>
setDropDownSearchMatchMode :: (MonadIO m, IsDropDown o) => o -> StringFilterMatchMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>selected</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDropDownSelected :: (IsDropDown o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>selected</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #selected
--   </pre>
getDropDownSelected :: (MonadIO m, IsDropDown o) => o -> m Word32

-- | Set the value of the “<tt>selected</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #selected <a>:=</a> value ]
--   </pre>
setDropDownSelected :: (MonadIO m, IsDropDown o) => o -> Word32 -> m ()

-- | Get the value of the “<tt>selected-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #selectedItem
--   </pre>
getDropDownSelectedItem :: (MonadIO m, IsDropDown o) => o -> m (Maybe Object)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-arrow</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDropDownShowArrow :: (IsDropDown o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropDown #showArrow
--   </pre>
getDropDownShowArrow :: (MonadIO m, IsDropDown o) => o -> m Bool

-- | Set the value of the “<tt>show-arrow</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dropDown [ #showArrow <a>:=</a> value ]
--   </pre>
setDropDownShowArrow :: (MonadIO m, IsDropDown o) => o -> Bool -> m ()

-- | Emitted to when the drop down is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkDropDown</tt> is an action
--   signal and emitting it causes the drop down to pop up its dropdown.
--   
--   <i>Since: 4.6</i>
type DropDownActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropDown #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropDownActivate :: (IsDropDown a, MonadIO m) => a -> ((?self :: a) => DropDownActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropDown #activate callback
--   </pre>
onDropDownActivate :: (IsDropDown a, MonadIO m) => a -> ((?self :: a) => DropDownActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.DropDown.DropDown
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DropDown.DropDown
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DropDown.DropDown
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DropDown.DropDown o) => GI.Gtk.Objects.DropDown.IsDropDown o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DropDown.DropDown)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DropDown.DropDown
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DropDown.DropDown


-- | An event controller tracking the pointer during Drag-and-Drop
--   operations.
--   
--   It is modeled after <a>EventControllerMotion</a> so if you have used
--   that, this should feel really familiar.
--   
--   This controller is not able to accept drops, use <a>DropTarget</a> for
--   that purpose.
module GI.Gtk.Objects.DropControllerMotion

-- | Memory-managed wrapper type.
newtype DropControllerMotion
DropControllerMotion :: ManagedPtr DropControllerMotion -> DropControllerMotion

-- | Type class for types which can be safely cast to
--   <a>DropControllerMotion</a>, for instance with
--   <a>toDropControllerMotion</a>.
class (GObject o, IsDescendantOf DropControllerMotion o) => IsDropControllerMotion o

-- | Cast to <a>DropControllerMotion</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toDropControllerMotion :: (MonadIO m, IsDropControllerMotion o) => o -> m DropControllerMotion

-- | Returns if a Drag-and-Drop operation is within the widget
--   <i><tt>self</tt></i> or one of its children.
dropControllerMotionContainsPointer :: (HasCallStack, MonadIO m, IsDropControllerMotion a) => a -> m Bool

-- | Returns the <tt>GdkDrop</tt> of a current Drag-and-Drop operation over
--   the widget of <i><tt>self</tt></i>.
dropControllerMotionGetDrop :: (HasCallStack, MonadIO m, IsDropControllerMotion a) => a -> m (Maybe Drop)

-- | Returns if a Drag-and-Drop operation is within the widget
--   <i><tt>self</tt></i>, not one of its children.
dropControllerMotionIsPointer :: (HasCallStack, MonadIO m, IsDropControllerMotion a) => a -> m Bool

-- | Creates a new event controller that will handle pointer motion events
--   during drag and drop.
dropControllerMotionNew :: (HasCallStack, MonadIO m) => m DropControllerMotion

-- | Get the value of the “<tt>contains-pointer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropControllerMotion #containsPointer
--   </pre>
getDropControllerMotionContainsPointer :: (MonadIO m, IsDropControllerMotion o) => o -> m Bool

-- | Get the value of the “<tt>drop</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropControllerMotion #drop
--   </pre>
getDropControllerMotionDrop :: (MonadIO m, IsDropControllerMotion o) => o -> m (Maybe Drop)

-- | Get the value of the “<tt>is-pointer</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dropControllerMotion #isPointer
--   </pre>
getDropControllerMotionIsPointer :: (MonadIO m, IsDropControllerMotion o) => o -> m Bool

-- | Signals that the pointer has entered the widget.
type DropControllerMotionEnterCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>enter</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropControllerMotion #enter callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropControllerMotionEnter :: (IsDropControllerMotion a, MonadIO m) => a -> ((?self :: a) => DropControllerMotionEnterCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>enter</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dropControllerMotion #enter callback
--   </pre>
onDropControllerMotionEnter :: (IsDropControllerMotion a, MonadIO m) => a -> ((?self :: a) => DropControllerMotionEnterCallback) -> m SignalHandlerId

-- | Signals that the pointer has left the widget.
type DropControllerMotionLeaveCallback = IO ()

-- | Connect a signal handler for the <a>leave</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropControllerMotion #leave callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropControllerMotionLeave :: (IsDropControllerMotion a, MonadIO m) => a -> ((?self :: a) => DropControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>leave</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dropControllerMotion #leave callback
--   </pre>
onDropControllerMotionLeave :: (IsDropControllerMotion a, MonadIO m) => a -> ((?self :: a) => DropControllerMotionLeaveCallback) -> m SignalHandlerId

-- | Emitted when the pointer moves inside the widget.
type DropControllerMotionMotionCallback = Double -> Double -> IO ()

-- | Connect a signal handler for the <a>motion</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dropControllerMotion #motion callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDropControllerMotionMotion :: (IsDropControllerMotion a, MonadIO m) => a -> ((?self :: a) => DropControllerMotionMotionCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>motion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dropControllerMotion #motion callback
--   </pre>
onDropControllerMotionMotion :: (IsDropControllerMotion a, MonadIO m) => a -> ((?self :: a) => DropControllerMotionMotionCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.DropControllerMotion.DropControllerMotion
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DropControllerMotion.DropControllerMotion
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DropControllerMotion.DropControllerMotion
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DropControllerMotion.DropControllerMotion o) => GI.Gtk.Objects.DropControllerMotion.IsDropControllerMotion o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DropControllerMotion.DropControllerMotion)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DropControllerMotion.DropControllerMotion
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DropControllerMotion.DropControllerMotion


-- | Allows drawing with cairo.
--   
--   &lt;picture&gt; &lt;source srcset="drawingarea-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkDrawingArea" src="drawingarea.png"&gt; &lt;/picture&gt;
--   
--   It’s essentially a blank widget; you can draw on it. After creating a
--   drawing area, the application may want to connect to:
--   
--   <ul>
--   <li>The <a>Widget::realize</a> signal to take any necessary actions
--   when the widget is instantiated on a particular display. (Create GDK
--   resources in response to this signal.)</li>
--   <li>The <a>DrawingArea::resize</a> signal to take any necessary
--   actions when the widget changes size.</li>
--   <li>Call <a>drawingAreaSetDrawFunc</a> to handle redrawing the
--   contents of the widget.</li>
--   </ul>
--   
--   The following code portion demonstrates using a drawing area to
--   display a circle in the normal widget foreground color.
--   
--   <h2>Simple GtkDrawingArea usage</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   draw_function (GtkDrawingArea *area,
--                  cairo_t        *cr,
--                  int             width,
--                  int             height,
--                  gpointer        data)
--   {
--     GdkRGBA color;
--   
--     cairo_arc (cr,
--                width / 2.0, height / 2.0,
--                MIN (width, height) / 2.0,
--                0, 2 * G_PI);
--   
--     gtk_widget_get_color (GTK_WIDGET (area),
--                           &amp;color);
--     gdk_cairo_set_source_rgba (cr, &amp;color);
--   
--     cairo_fill (cr);
--   }
--   
--   int
--   main (int argc, char **argv)
--   {
--     gtk_init ();
--   
--     GtkWidget *area = gtk_drawing_area_new ();
--     gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (area), 100);
--     gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (area), 100);
--     gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (area),
--                                     draw_function,
--                                     NULL, NULL);
--     return 0;
--   }
--   </pre>
--   
--   The draw function is normally called when a drawing area first comes
--   onscreen, or when it’s covered by another window and then uncovered.
--   You can also force a redraw by adding to the “damage region” of the
--   drawing area’s window using <a>widgetQueueDraw</a>. This will cause
--   the drawing area to call the draw function again.
--   
--   The available routines for drawing are documented in the <a>Cairo
--   documentation</a>; GDK offers additional API to integrate with Cairo,
--   like <a>cairoSetSourceRgba</a> or <a>cairoSetSourcePixbuf</a>.
--   
--   To receive mouse events on a drawing area, you will need to use event
--   controllers. To receive keyboard events, you will need to set the
--   “can-focus” property on the drawing area, and you should probably draw
--   some user-visible indication that the drawing area is focused.
--   
--   If you need more complex control over your widget, you should consider
--   creating your own <tt>GtkWidget</tt> subclass.
module GI.Gtk.Objects.DrawingArea

-- | Memory-managed wrapper type.
newtype DrawingArea
DrawingArea :: ManagedPtr DrawingArea -> DrawingArea

-- | Type class for types which can be safely cast to <a>DrawingArea</a>,
--   for instance with <a>toDrawingArea</a>.
class (GObject o, IsDescendantOf DrawingArea o) => IsDrawingArea o

-- | Cast to <a>DrawingArea</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDrawingArea :: (MonadIO m, IsDrawingArea o) => o -> m DrawingArea

-- | Retrieves the content height of the <tt>GtkDrawingArea</tt>.
drawingAreaGetContentHeight :: (HasCallStack, MonadIO m, IsDrawingArea a) => a -> m Int32

-- | Retrieves the content width of the <tt>GtkDrawingArea</tt>.
drawingAreaGetContentWidth :: (HasCallStack, MonadIO m, IsDrawingArea a) => a -> m Int32

-- | Creates a new drawing area.
drawingAreaNew :: (HasCallStack, MonadIO m) => m DrawingArea

-- | Sets the desired height of the contents of the drawing area.
--   
--   Note that because widgets may be allocated larger sizes than they
--   requested, it is possible that the actual height passed to your draw
--   function is larger than the height set here. You can use
--   <a>widgetSetValign</a> to avoid that.
--   
--   If the height is set to 0 (the default), the drawing area may
--   disappear.
drawingAreaSetContentHeight :: (HasCallStack, MonadIO m, IsDrawingArea a) => a -> Int32 -> m ()

-- | Sets the desired width of the contents of the drawing area.
--   
--   Note that because widgets may be allocated larger sizes than they
--   requested, it is possible that the actual width passed to your draw
--   function is larger than the width set here. You can use
--   <a>widgetSetHalign</a> to avoid that.
--   
--   If the width is set to 0 (the default), the drawing area may
--   disappear.
drawingAreaSetContentWidth :: (HasCallStack, MonadIO m, IsDrawingArea a) => a -> Int32 -> m ()

-- | Setting a draw function is the main thing you want to do when using a
--   drawing area.
--   
--   The draw function is called whenever GTK needs to draw the contents of
--   the drawing area to the screen.
--   
--   The draw function will be called during the drawing stage of GTK. In
--   the drawing stage it is not allowed to change properties of any GTK
--   widgets or call any functions that would cause any properties to be
--   changed. You should restrict yourself exclusively to drawing your
--   contents in the draw function.
--   
--   If what you are drawing does change, call <a>widgetQueueDraw</a> on
--   the drawing area. This will cause a redraw and will call
--   <i><tt>drawFunc</tt></i> again.
drawingAreaSetDrawFunc :: (HasCallStack, MonadIO m, IsDrawingArea a) => a -> Maybe DrawingAreaDrawFunc -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>content-height</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDrawingAreaContentHeight :: (IsDrawingArea o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> drawingArea #contentHeight
--   </pre>
getDrawingAreaContentHeight :: (MonadIO m, IsDrawingArea o) => o -> m Int32

-- | Set the value of the “<tt>content-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> drawingArea [ #contentHeight <a>:=</a> value ]
--   </pre>
setDrawingAreaContentHeight :: (MonadIO m, IsDrawingArea o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>content-width</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructDrawingAreaContentWidth :: (IsDrawingArea o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> drawingArea #contentWidth
--   </pre>
getDrawingAreaContentWidth :: (MonadIO m, IsDrawingArea o) => o -> m Int32

-- | Set the value of the “<tt>content-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> drawingArea [ #contentWidth <a>:=</a> value ]
--   </pre>
setDrawingAreaContentWidth :: (MonadIO m, IsDrawingArea o) => o -> Int32 -> m ()

-- | Emitted once when the widget is realized, and then each time the
--   widget is changed while realized.
--   
--   This is useful in order to keep state up to date with the widget size,
--   like for instance a backing surface.
type DrawingAreaResizeCallback = Int32 -> Int32 -> IO ()

-- | Connect a signal handler for the <a>resize</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> drawingArea #resize callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDrawingAreaResize :: (IsDrawingArea a, MonadIO m) => a -> ((?self :: a) => DrawingAreaResizeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>resize</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> drawingArea #resize callback
--   </pre>
onDrawingAreaResize :: (IsDrawingArea a, MonadIO m) => a -> ((?self :: a) => DrawingAreaResizeCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.DrawingArea.DrawingArea
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DrawingArea.DrawingArea
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DrawingArea.DrawingArea
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DrawingArea.DrawingArea o) => GI.Gtk.Objects.DrawingArea.IsDrawingArea o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DrawingArea.DrawingArea)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DrawingArea.DrawingArea
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DrawingArea.DrawingArea


-- | An event controller to initiate Drag-And-Drop operations.
--   
--   <tt>GtkDragSource</tt> can be set up with the necessary ingredients
--   for a DND operation ahead of time. This includes the source for the
--   data that is being transferred, in the form of a
--   <a>ContentProvider</a>, the desired action, and the icon to use during
--   the drag operation. After setting it up, the drag source must be added
--   to a widget as an event controller, using <a>widgetAddController</a>.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   my_widget_init (MyWidget *self)
--   {
--     GtkDragSource *drag_source = gtk_drag_source_new ();
--   
--     g_signal_connect (drag_source, "prepare", G_CALLBACK (on_drag_prepare), self);
--     g_signal_connect (drag_source, "drag-begin", G_CALLBACK (on_drag_begin), self);
--   
--     gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag_source));
--   }
--   </pre>
--   
--   Setting up the content provider and icon ahead of time only makes
--   sense when the data does not change. More commonly, you will want to
--   set them up just in time. To do so, <tt>GtkDragSource</tt> has
--   <a>DragSource::prepare</a> and <a>DragSource::dragBegin</a> signals.
--   
--   The <a>prepare</a> signal is emitted before a drag is started, and can
--   be used to set the content provider and actions that the drag should
--   be started with.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static GdkContentProvider *
--   on_drag_prepare (GtkDragSource *source,
--                    double         x,
--                    double         y,
--                    MyWidget      *self)
--   {
--     // This widget supports two types of content: GFile objects
--     // and GdkPixbuf objects; GTK will handle the serialization
--     // of these types automatically
--     GFile *file = my_widget_get_file (self);
--     GdkPixbuf *pixbuf = my_widget_get_pixbuf (self);
--   
--     return gdk_content_provider_new_union ((GdkContentProvider *[2]) {
--         gdk_content_provider_new_typed (G_TYPE_FILE, file),
--         gdk_content_provider_new_typed (GDK_TYPE_PIXBUF, pixbuf),
--       }, 2);
--   }
--   </pre>
--   
--   The <a>dragBegin</a> signal is emitted after the <tt>GdkDrag</tt>
--   object has been created, and can be used to set up the drag icon.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   on_drag_begin (GtkDragSource *source,
--                  GdkDrag       *drag,
--                  MyWidget      *self)
--   {
--     // Set the widget as the drag icon
--     GdkPaintable *paintable = gtk_widget_paintable_new (GTK_WIDGET (self));
--     gtk_drag_source_set_icon (source, paintable, 0, 0);
--     g_object_unref (paintable);
--   }
--   </pre>
--   
--   During the DND operation, <tt>GtkDragSource</tt> emits signals that
--   can be used to obtain updates about the status of the operation, but
--   it is not normally necessary to connect to any signals, except for one
--   case: when the supported actions include <a>DragActionMove</a>, you
--   need to listen for the <a>DragSource::dragEnd</a> signal and delete
--   the data after it has been transferred.
module GI.Gtk.Objects.DragSource

-- | Memory-managed wrapper type.
newtype DragSource
DragSource :: ManagedPtr DragSource -> DragSource

-- | Type class for types which can be safely cast to <a>DragSource</a>,
--   for instance with <a>toDragSource</a>.
class (GObject o, IsDescendantOf DragSource o) => IsDragSource o

-- | Cast to <a>DragSource</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDragSource :: (MonadIO m, IsDragSource o) => o -> m DragSource

-- | Cancels a currently ongoing drag operation.
dragSourceDragCancel :: (HasCallStack, MonadIO m, IsDragSource a) => a -> m ()

-- | Gets the actions that are currently set on the <tt>GtkDragSource</tt>.
dragSourceGetActions :: (HasCallStack, MonadIO m, IsDragSource a) => a -> m [DragAction]

-- | Gets the current content provider of a <tt>GtkDragSource</tt>.
dragSourceGetContent :: (HasCallStack, MonadIO m, IsDragSource a) => a -> m (Maybe ContentProvider)

-- | Returns the underlying <tt>GdkDrag</tt> object for an ongoing drag.
dragSourceGetDrag :: (HasCallStack, MonadIO m, IsDragSource a) => a -> m (Maybe Drag)

-- | Creates a new <tt>GtkDragSource</tt> object.
dragSourceNew :: (HasCallStack, MonadIO m) => m DragSource

-- | Sets the actions on the <tt>GtkDragSource</tt>.
--   
--   During a DND operation, the actions are offered to potential drop
--   targets. If <i><tt>actions</tt></i> include <a>DragActionMove</a>, you
--   need to listen to the <a>DragSource::dragEnd</a> signal and handle
--   <i><tt>deleteData</tt></i> being <a>True</a>.
--   
--   This function can be called before a drag is started, or in a handler
--   for the <a>DragSource::prepare</a> signal.
dragSourceSetActions :: (HasCallStack, MonadIO m, IsDragSource a) => a -> [DragAction] -> m ()

-- | Sets a content provider on a <tt>GtkDragSource</tt>.
--   
--   When the data is requested in the cause of a DND operation, it will be
--   obtained from the content provider.
--   
--   This function can be called before a drag is started, or in a handler
--   for the <a>DragSource::prepare</a> signal.
--   
--   You may consider setting the content provider back to <a>Nothing</a>
--   in a <a>DragSource::dragEnd</a> signal handler.
dragSourceSetContent :: (HasCallStack, MonadIO m, IsDragSource a, IsContentProvider b) => a -> Maybe b -> m ()

-- | Sets a paintable to use as icon during DND operations.
--   
--   The hotspot coordinates determine the point on the icon that gets
--   aligned with the hotspot of the cursor.
--   
--   If <i><tt>paintable</tt></i> is <a>Nothing</a>, a default icon is
--   used.
--   
--   This function can be called before a drag is started, or in a
--   <a>DragSource::prepare</a> or <a>DragSource::dragBegin</a> signal
--   handler.
dragSourceSetIcon :: (HasCallStack, MonadIO m, IsDragSource a, IsPaintable b) => a -> Maybe b -> Int32 -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>actions</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDragSourceActions :: (IsDragSource o, MonadIO m) => [DragAction] -> m (GValueConstruct o)

-- | Get the value of the “<tt>actions</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dragSource #actions
--   </pre>
getDragSourceActions :: (MonadIO m, IsDragSource o) => o -> m [DragAction]

-- | Set the value of the “<tt>actions</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dragSource [ #actions <a>:=</a> value ]
--   </pre>
setDragSourceActions :: (MonadIO m, IsDragSource o) => o -> [DragAction] -> m ()

-- | Set the value of the “<tt>content</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #content
--   </pre>
clearDragSourceContent :: (MonadIO m, IsDragSource o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>content</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDragSourceContent :: (IsDragSource o, MonadIO m, IsContentProvider a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>content</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dragSource #content
--   </pre>
getDragSourceContent :: (MonadIO m, IsDragSource o) => o -> m (Maybe ContentProvider)

-- | Set the value of the “<tt>content</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dragSource [ #content <a>:=</a> value ]
--   </pre>
setDragSourceContent :: (MonadIO m, IsDragSource o, IsContentProvider a) => o -> a -> m ()

-- | Emitted on the drag source when a drag is started.
--   
--   It can be used to e.g. set a custom drag icon with
--   <a>dragSourceSetIcon</a>.
type DragSourceDragBeginCallback = Drag -> IO ()

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dragSource #dragBegin callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDragSourceDragBegin :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourceDragBeginCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragBegin</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dragSource #dragBegin callback
--   </pre>
onDragSourceDragBegin :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourceDragBeginCallback) -> m SignalHandlerId

-- | Emitted on the drag source when a drag has failed.
--   
--   The signal handler may handle a failed drag operation based on the
--   type of error. It should return <a>True</a> if the failure has been
--   handled and the default "drag operation failed" animation should not
--   be shown.
type DragSourceDragCancelCallback = Drag -> DragCancelReason -> IO Bool

-- | Connect a signal handler for the <a>dragCancel</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dragSource #dragCancel callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDragSourceDragCancel :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourceDragCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragCancel</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dragSource #dragCancel callback
--   </pre>
onDragSourceDragCancel :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourceDragCancelCallback) -> m SignalHandlerId

-- | Emitted on the drag source when a drag is finished.
--   
--   A typical reason to connect to this signal is to undo things done in
--   <a>DragSource::prepare</a> or <a>DragSource::dragBegin</a> handlers.
type DragSourceDragEndCallback = Drag -> Bool -> IO ()

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dragSource #dragEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDragSourceDragEnd :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourceDragEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>dragEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dragSource #dragEnd callback
--   </pre>
onDragSourceDragEnd :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourceDragEndCallback) -> m SignalHandlerId

-- | Emitted when a drag is about to be initiated.
--   
--   It returns the <tt>GdkContentProvider</tt> to use for the drag that is
--   about to start. The default handler for this signal returns the value
--   of the <a>DragSource:content</a> property, so if you set up that
--   property ahead of time, you don't need to connect to this signal.
type DragSourcePrepareCallback = Double -> Double -> IO Maybe ContentProvider

-- | Connect a signal handler for the <a>prepare</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dragSource #prepare callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDragSourcePrepare :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourcePrepareCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prepare</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dragSource #prepare callback
--   </pre>
onDragSourcePrepare :: (IsDragSource a, MonadIO m) => a -> ((?self :: a) => DragSourcePrepareCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.DragSource.DragSource
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DragSource.DragSource
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DragSource.DragSource
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DragSource.DragSource o) => GI.Gtk.Objects.DragSource.IsDragSource o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DragSource.DragSource)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DragSource.DragSource
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DragSource.DragSource


-- | A <tt>GtkRoot</tt> implementation for drag icons.
--   
--   A drag icon moves with the pointer during a Drag-and-Drop operation
--   and is destroyed when the drag ends.
--   
--   To set up a drag icon and associate it with an ongoing drag operation,
--   use <a>dragIconGetForDrag</a> to get the icon for a drag. You can then
--   use it like any other widget and use <a>dragIconSetChild</a> to set
--   whatever widget should be used for the drag icon.
--   
--   Keep in mind that drag icons do not allow user input.
module GI.Gtk.Objects.DragIcon

-- | Memory-managed wrapper type.
newtype DragIcon
DragIcon :: ManagedPtr DragIcon -> DragIcon

-- | Type class for types which can be safely cast to <a>DragIcon</a>, for
--   instance with <a>toDragIcon</a>.
class (GObject o, IsDescendantOf DragIcon o) => IsDragIcon o

-- | Cast to <a>DragIcon</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toDragIcon :: (MonadIO m, IsDragIcon o) => o -> m DragIcon

-- | Creates a widget that can be used as a drag icon for the given
--   <i><tt>value</tt></i>.
--   
--   Supported types include strings, <tt>GdkRGBA</tt> and
--   <tt>GtkTextBuffer</tt>. If GTK does not know how to create a widget
--   for a given value, it will return <a>Nothing</a>.
--   
--   This method is used to set the default drag icon on drag-and-drop
--   operations started by <tt>GtkDragSource</tt>, so you don't need to set
--   a drag icon using this function there.
dragIconCreateWidgetForValue :: (HasCallStack, MonadIO m) => GValue -> m (Maybe Widget)

-- | Gets the widget currently used as drag icon.
dragIconGetChild :: (HasCallStack, MonadIO m, IsDragIcon a) => a -> m (Maybe Widget)

-- | Gets the <tt>GtkDragIcon</tt> in use with <i><tt>drag</tt></i>.
--   
--   If no drag icon exists yet, a new one will be created and shown.
dragIconGetForDrag :: (HasCallStack, MonadIO m, IsDrag a) => a -> m DragIcon

-- | Sets the widget to display as the drag icon.
dragIconSetChild :: (HasCallStack, MonadIO m, IsDragIcon a, IsWidget b) => a -> Maybe b -> m ()

-- | Creates a <tt>GtkDragIcon</tt> that shows <i><tt>paintable</tt></i>,
--   and associates it with the drag operation.
--   
--   The hotspot position on the paintable is aligned with the hotspot of
--   the cursor.
dragIconSetFromPaintable :: (HasCallStack, MonadIO m, IsDrag a, IsPaintable b) => a -> b -> Int32 -> Int32 -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearDragIconChild :: (MonadIO m, IsDragIcon o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDragIconChild :: (IsDragIcon o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dragIcon #child
--   </pre>
getDragIconChild :: (MonadIO m, IsDragIcon o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> dragIcon [ #child <a>:=</a> value ]
--   </pre>
setDragIconChild :: (MonadIO m, IsDragIcon o, IsWidget a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.DragIcon.DragIcon
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.DragIcon.DragIcon
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.DragIcon.DragIcon
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.DragIcon.DragIcon o) => GI.Gtk.Objects.DragIcon.IsDragIcon o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.DragIcon.DragIcon)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.DragIcon.DragIcon
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.DragIcon.DragIcon


-- | Dialogs are a convenient way to prompt the user for a small amount of
--   input.
--   
--   &lt;picture&gt; &lt;source srcset="dialog-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkDialog" src="dialog.png"&gt; &lt;/picture&gt;
--   
--   Typical uses are to display a message, ask a question, or anything
--   else that does not require extensive effort on the user’s part.
--   
--   The main area of a <tt>GtkDialog</tt> is called the "content area",
--   and is yours to populate with widgets such a <tt>GtkLabel</tt> or
--   <tt>GtkEntry</tt>, to present your information, questions, or tasks to
--   the user.
--   
--   In addition, dialogs allow you to add "action widgets". Most commonly,
--   action widgets are buttons. Depending on the platform, action widgets
--   may be presented in the header bar at the top of the window, or at the
--   bottom of the window. To add action widgets, create your
--   <tt>GtkDialog</tt> using
--   <a>Dialog</a>.<tt><i>new_with_buttons</i></tt>(), or use
--   <a>dialogAddButton</a>, <a>Dialog</a>.<tt><i>add_buttons</i></tt>(),
--   or <a>dialogAddActionWidget</a>.
--   
--   <tt>GtkDialogs</tt> uses some heuristics to decide whether to add a
--   close button to the window decorations. If any of the action buttons
--   use the response ID <a>ResponseTypeClose</a> or
--   <a>ResponseTypeCancel</a>, the close button is omitted.
--   
--   Clicking a button that was added as an action widget will emit the
--   <a>Dialog::response</a> signal with a response ID that you specified.
--   GTK will never assign a meaning to positive response IDs; these are
--   entirely user-defined. But for convenience, you can use the response
--   IDs in the <a>ResponseType</a> enumeration (these all have values less
--   than zero). If a dialog receives a delete event, the
--   <a>Dialog::response</a> signal will be emitted with the
--   <a>ResponseTypeDeleteEvent</a> response ID.
--   
--   Dialogs are created with a call to <a>dialogNew</a> or
--   <a>Dialog</a>.<tt><i>new_with_buttons</i></tt>(). The latter is
--   recommended; it allows you to set the dialog title, some convenient
--   flags, and add buttons.
--   
--   A “modal” dialog (that is, one which freezes the rest of the
--   application from user input), can be created by calling
--   <a>windowSetModal</a> on the dialog. When using
--   <a>Dialog</a>.<tt><i>new_with_buttons</i></tt>(), you can also pass
--   the <a>DialogFlagsModal</a> flag to make a dialog modal.
--   
--   For the simple dialog in the following example, a <a>MessageDialog</a>
--   would save some effort. But you’d need to create the dialog contents
--   manually if you had more than a simple message in the dialog.
--   
--   An example for simple <tt>GtkDialog</tt> usage:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // Function to open a dialog box with a message
--   void
--   quick_message (GtkWindow *parent, char *message)
--   {
--    GtkWidget *dialog, *label, *content_area;
--    GtkDialogFlags flags;
--   
--    // Create the widgets
--    flags = GTK_DIALOG_DESTROY_WITH_PARENT;
--    dialog = gtk_dialog_new_with_buttons ("Message",
--                                          parent,
--                                          flags,
--                                          _("_OK"),
--                                          GTK_RESPONSE_NONE,
--                                          NULL);
--    content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
--    label = gtk_label_new (message);
--   
--    // Ensure that the dialog box is destroyed when the user responds
--   
--    g_signal_connect_swapped (dialog,
--                              "response",
--                              G_CALLBACK (gtk_window_destroy),
--                              dialog);
--   
--    // Add the label, and show everything we’ve added
--   
--    gtk_box_append (GTK_BOX (content_area), label);
--    gtk_widget_show (dialog);
--   }
--   </pre>
--   
--   <h1>GtkDialog as GtkBuildable</h1>
--   
--   The <tt>GtkDialog</tt> implementation of the <tt>GtkBuildable</tt>
--   interface exposes the <i><tt>contentArea</tt></i> as an internal child
--   with the name “content_area”.
--   
--   <tt>GtkDialog</tt> supports a custom <tt>&lt;action-widgets&gt;</tt>
--   element, which can contain multiple <tt>&lt;action-widget&gt;</tt>
--   elements. The “response” attribute specifies a numeric response, and
--   the content of the element is the id of widget (which should be a
--   child of the dialogs <i><tt>actionArea</tt></i>). To mark a response
--   as default, set the “default” attribute of the
--   <tt>&lt;action-widget&gt;</tt> element to true.
--   
--   <tt>GtkDialog</tt> supports adding action widgets by specifying
--   “action” as the “type” attribute of a <tt>&lt;child&gt;</tt> element.
--   The widget will be added either to the action area or the headerbar of
--   the dialog, depending on the “use-header-bar” property. The response
--   id has to be associated with the action widget using the
--   <tt>&lt;action-widgets&gt;</tt> element.
--   
--   An example of a <tt>GtkDialog</tt> UI definition fragment:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkDialog" id="dialog1"&gt;
--     &lt;child type="action"&gt;
--       &lt;object class="GtkButton" id="button_cancel"/&gt;
--     &lt;/child&gt;
--     &lt;child type="action"&gt;
--       &lt;object class="GtkButton" id="button_ok"&gt;
--       &lt;/object&gt;
--     &lt;/child&gt;
--     &lt;action-widgets&gt;
--       &lt;action-widget response="cancel"&gt;button_cancel&lt;/action-widget&gt;
--       &lt;action-widget response="ok" default="true"&gt;button_ok&lt;/action-widget&gt;
--     &lt;/action-widgets&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkDialog</tt> uses the <a>AccessibleRoleDialog</a> role.
module GI.Gtk.Objects.Dialog

-- | Memory-managed wrapper type.
newtype Dialog
Dialog :: ManagedPtr Dialog -> Dialog

-- | Type class for types which can be safely cast to <a>Dialog</a>, for
--   instance with <a>toDialog</a>.
class (GObject o, IsDescendantOf Dialog o) => IsDialog o

-- | Cast to <a>Dialog</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toDialog :: (MonadIO m, IsDialog o) => o -> m Dialog

-- | Adds an activatable widget to the action area of a <tt>GtkDialog</tt>.
--   
--   GTK connects a signal handler that will emit the
--   <a>Dialog::response</a> signal on the dialog when the widget is
--   activated. The widget is appended to the end of the dialog’s action
--   area.
--   
--   If you want to add a non-activatable widget, simply pack it into the
--   <i><tt>actionArea</tt></i> field of the <tt>GtkDialog</tt> struct.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogAddActionWidget :: (HasCallStack, MonadIO m, IsDialog a, IsWidget b) => a -> b -> Int32 -> m ()

-- | Adds a button with the given text.
--   
--   GTK arranges things so that clicking the button will emit the
--   <a>Dialog::response</a> signal with the given
--   <i><tt>responseId</tt></i>. The button is appended to the end of the
--   dialog’s action area. The button widget is returned, but usually you
--   don’t need it.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogAddButton :: (HasCallStack, MonadIO m, IsDialog a) => a -> Text -> Int32 -> m Widget

-- | Returns the content area of <i><tt>dialog</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogGetContentArea :: (HasCallStack, MonadIO m, IsDialog a) => a -> m Box

-- | Returns the header bar of <i><tt>dialog</tt></i>.
--   
--   Note that the headerbar is only used by the dialog if the
--   <a>Dialog:useHeaderBar</a> property is <a>True</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogGetHeaderBar :: (HasCallStack, MonadIO m, IsDialog a) => a -> m HeaderBar

-- | Gets the response id of a widget in the action area of a dialog.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogGetResponseForWidget :: (HasCallStack, MonadIO m, IsDialog a, IsWidget b) => a -> b -> m Int32

-- | Gets the widget button that uses the given response ID in the action
--   area of a dialog.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogGetWidgetForResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m (Maybe Widget)

-- | Creates a new dialog box.
--   
--   Widgets should not be packed into the <tt>GtkWindow</tt> directly, but
--   into the <i><tt>contentArea</tt></i> and <i><tt>actionArea</tt></i>,
--   as described above.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogNew :: (HasCallStack, MonadIO m) => m Dialog

-- | Emits the <a>response</a> signal with the given response ID.
--   
--   Used to indicate that the user has responded to the dialog in some
--   way.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m ()

-- | Sets the default widget for the dialog based on the response ID.
--   
--   Pressing “Enter” normally activates the default widget.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogSetDefaultResponse :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> m ()

-- | A convenient way to sensitize/desensitize dialog buttons.
--   
--   Calls <tt>gtk_widget_set_sensitive (widget, @setting)</tt> for each
--   widget in the dialog’s action area with the given
--   <i><tt>responseId</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
dialogSetResponseSensitive :: (HasCallStack, MonadIO m, IsDialog a) => a -> Int32 -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-header-bar</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDialogUseHeaderBar :: (IsDialog o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-header-bar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> dialog #useHeaderBar
--   </pre>
getDialogUseHeaderBar :: (MonadIO m, IsDialog o) => o -> m Int32

-- | Emitted when the user uses a keybinding to close the dialog.
--   
--   This is a <a>keybinding signal</a>.
--   
--   The default binding for this signal is the Escape key.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
type DialogCloseCallback = IO ()

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dialog #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDialogClose :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> dialog #close callback
--   </pre>
onDialogClose :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseCallback) -> m SignalHandlerId

-- | Emitted when an action widget is clicked.
--   
--   The signal is also emitted when the dialog receives a delete event,
--   and when <a>dialogResponse</a> is called. On a delete event, the
--   response ID is <a>ResponseTypeDeleteEvent</a>. Otherwise, it depends
--   on which action widget was clicked.

-- | <i>Deprecated: (Since version 4.10)Use <a>Window</a> instead</i>
type DialogResponseCallback = Int32 -> IO ()

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> dialog #response callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterDialogResponse :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogResponseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>response</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> dialog #response callback
--   </pre>
onDialogResponse :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogResponseCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Dialog.Dialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Dialog.Dialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Dialog.Dialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Dialog.Dialog o) => GI.Gtk.Objects.Dialog.IsDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Dialog.Dialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Dialog.Dialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Dialog.Dialog


-- | Uses closures for size negotiation.
--   
--   A <tt>GtkCustomLayout</tt> uses closures matching to the old
--   <tt>GtkWidget</tt> virtual functions for size negotiation, as a
--   convenience API to ease the porting towards the corresponding
--   <tt>GtkLayoutManager</tt> virtual functions.
module GI.Gtk.Objects.CustomLayout

-- | Memory-managed wrapper type.
newtype CustomLayout
CustomLayout :: ManagedPtr CustomLayout -> CustomLayout

-- | Type class for types which can be safely cast to <a>CustomLayout</a>,
--   for instance with <a>toCustomLayout</a>.
class (GObject o, IsDescendantOf CustomLayout o) => IsCustomLayout o

-- | Cast to <a>CustomLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCustomLayout :: (MonadIO m, IsCustomLayout o) => o -> m CustomLayout

-- | Creates a new legacy layout manager.
--   
--   Legacy layout managers map to the old <tt>GtkWidget</tt> size
--   negotiation virtual functions, and are meant to be used during the
--   transition from layout containers to layout manager delegates.
customLayoutNew :: (HasCallStack, MonadIO m) => Maybe CustomRequestModeFunc -> CustomMeasureFunc -> CustomAllocateFunc -> m CustomLayout
instance GHC.Classes.Eq GI.Gtk.Objects.CustomLayout.CustomLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CustomLayout.CustomLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CustomLayout.CustomLayout
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CustomLayout.CustomLayout o) => GI.Gtk.Objects.CustomLayout.IsCustomLayout o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CustomLayout.CustomLayout)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CustomLayout.CustomLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CustomLayout.CustomLayout


-- | Determines whether to include items with a callback.
module GI.Gtk.Objects.CustomFilter

-- | Memory-managed wrapper type.
newtype CustomFilter
CustomFilter :: ManagedPtr CustomFilter -> CustomFilter

-- | Type class for types which can be safely cast to <a>CustomFilter</a>,
--   for instance with <a>toCustomFilter</a>.
class (GObject o, IsDescendantOf CustomFilter o) => IsCustomFilter o

-- | Cast to <a>CustomFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCustomFilter :: (MonadIO m, IsCustomFilter o) => o -> m CustomFilter

-- | Creates a new filter using the given function to filter items.
--   
--   If <i><tt>matchFunc</tt></i> is <tt>NULL</tt>, the filter matches all
--   items.
--   
--   If the filter func changes its filtering behavior,
--   <a>filterChanged</a> needs to be called.
customFilterNew :: (HasCallStack, MonadIO m) => Maybe CustomFilterFunc -> m CustomFilter

-- | Sets the function used for filtering items.
--   
--   If <i><tt>matchFunc</tt></i> is <tt>NULL</tt>, the filter matches all
--   items.
--   
--   If the filter func changes its filtering behavior,
--   <a>filterChanged</a> needs to be called.
--   
--   If a previous function was set, its <i><tt>userDestroy</tt></i> will
--   be called.
customFilterSetFilterFunc :: (HasCallStack, MonadIO m, IsCustomFilter a) => a -> Maybe CustomFilterFunc -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CustomFilter.CustomFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CustomFilter.CustomFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CustomFilter.CustomFilter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CustomFilter.CustomFilter o) => GI.Gtk.Objects.CustomFilter.IsCustomFilter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CustomFilter.CustomFilter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CustomFilter.CustomFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CustomFilter.CustomFilter


-- | <tt>GtkLayoutChild</tt> subclass for children in a
--   <tt>GtkConstraintLayout</tt>.
module GI.Gtk.Objects.ConstraintLayoutChild

-- | Memory-managed wrapper type.
newtype ConstraintLayoutChild
ConstraintLayoutChild :: ManagedPtr ConstraintLayoutChild -> ConstraintLayoutChild

-- | Type class for types which can be safely cast to
--   <a>ConstraintLayoutChild</a>, for instance with
--   <a>toConstraintLayoutChild</a>.
class (GObject o, IsDescendantOf ConstraintLayoutChild o) => IsConstraintLayoutChild o

-- | Cast to <a>ConstraintLayoutChild</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toConstraintLayoutChild :: (MonadIO m, IsConstraintLayoutChild o) => o -> m ConstraintLayoutChild
instance GHC.Classes.Eq GI.Gtk.Objects.ConstraintLayoutChild.ConstraintLayoutChild
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ConstraintLayoutChild.ConstraintLayoutChild
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ConstraintLayoutChild.ConstraintLayoutChild
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ConstraintLayoutChild.ConstraintLayoutChild o) => GI.Gtk.Objects.ConstraintLayoutChild.IsConstraintLayoutChild o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ConstraintLayoutChild.ConstraintLayoutChild)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ConstraintLayoutChild.ConstraintLayoutChild
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ConstraintLayoutChild.ConstraintLayoutChild


-- | Uses constraints to describe relations between widgets.
--   
--   <tt>GtkConstraintLayout</tt> is a layout manager that uses relations
--   between widget attributes, expressed via <a>Constraint</a> instances,
--   to measure and allocate widgets.
--   
--   <h3>How do constraints work</h3>
--   
--   Constraints are objects defining the relationship between attributes
--   of a widget; you can read the description of the <a>Constraint</a>
--   class to have a more in depth definition.
--   
--   By taking multiple constraints and applying them to the children of a
--   widget using <tt>GtkConstraintLayout</tt>, it's possible to describe
--   complex layout policies; each constraint applied to a child or to the
--   parent widgets contributes to the full description of the layout, in
--   terms of parameters for resolving the value of each attribute.
--   
--   It is important to note that a layout is defined by the totality of
--   constraints; removing a child, or a constraint, from an existing
--   layout without changing the remaining constraints may result in an
--   unstable or unsolvable layout.
--   
--   Constraints have an implicit "reading order"; you should start
--   describing each edge of each child, as well as their relationship with
--   the parent container, from the top left (or top right, in RTL
--   languages), horizontally first, and then vertically.
--   
--   A constraint-based layout with too few constraints can become
--   "unstable", that is: have more than one solution. The behavior of an
--   unstable layout is undefined.
--   
--   A constraint-based layout with conflicting constraints may be
--   unsolvable, and lead to an unstable layout. You can use the
--   <a>Constraint:strength</a> property of <a>Constraint</a> to "nudge"
--   the layout towards a solution.
--   
--   <h3>GtkConstraintLayout as GtkBuildable</h3>
--   
--   <tt>GtkConstraintLayout</tt> implements the <a>Buildable</a> interface
--   and has a custom "constraints" element which allows describing
--   constraints in a <a>Builder</a> UI file.
--   
--   An example of a UI definition fragment specifying a constraint:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkConstraintLayout"&gt;
--     &lt;constraints&gt;
--       &lt;constraint target="button" target-attribute="start"
--                   relation="eq"
--                   source="super" source-attribute="start"
--                   constant="12"
--                   strength="required" /&gt;
--       &lt;constraint target="button" target-attribute="width"
--                   relation="ge"
--                   constant="250"
--                   strength="strong" /&gt;
--     &lt;/constraints&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   The definition above will add two constraints to the
--   GtkConstraintLayout:
--   
--   <ul>
--   <li>a required constraint between the leading edge of "button" and the
--   leading edge of the widget using the constraint layout, plus 12
--   pixels</li>
--   <li>a strong, constant constraint making the width of "button" greater
--   than, or equal to 250 pixels</li>
--   </ul>
--   
--   The "target" and "target-attribute" attributes are required.
--   
--   The "source" and "source-attribute" attributes of the "constraint"
--   element are optional; if they are not specified, the constraint is
--   assumed to be a constant.
--   
--   The "relation" attribute is optional; if not specified, the constraint
--   is assumed to be an equality.
--   
--   The "strength" attribute is optional; if not specified, the constraint
--   is assumed to be required.
--   
--   The "source" and "target" attributes can be set to "super" to indicate
--   that the constraint target is the widget using the
--   GtkConstraintLayout.
--   
--   There can be "constant" and "multiplier" attributes.
--   
--   Additionally, the "constraints" element can also contain a description
--   of the <tt>GtkConstraintGuides</tt> used by the layout:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;constraints&gt;
--     &lt;guide min-width="100" max-width="500" name="hspace"/&gt;
--     &lt;guide min-height="64" nat-height="128" name="vspace" strength="strong"/&gt;
--   &lt;/constraints&gt;
--   </pre>
--   
--   The "guide" element has the following optional attributes:
--   
--   <ul>
--   <li>"min-width", "nat-width", and "max-width", describe the minimum,
--   natural, and maximum width of the guide, respectively</li>
--   <li>"min-height", "nat-height", and "max-height", describe the
--   minimum, natural, and maximum height of the guide, respectively</li>
--   <li>"strength" describes the strength of the constraint on the natural
--   size of the guide; if not specified, the constraint is assumed to have
--   a medium strength</li>
--   <li>"name" describes a name for the guide, useful when debugging</li>
--   </ul>
--   
--   <h3>Using the Visual Format Language</h3>
--   
--   Complex constraints can be described using a compact syntax called
--   VFL, or *Visual Format Language*.
--   
--   The Visual Format Language describes all the constraints on a row or
--   column, typically starting from the leading edge towards the trailing
--   one. Each element of the layout is composed by "views", which identify
--   a <a>ConstraintTarget</a>.
--   
--   For instance:
--   
--   <pre>
--   [button]-[textField]
--   </pre>
--   
--   Describes a constraint that binds the trailing edge of "button" to the
--   leading edge of "textField", leaving a default space between the two.
--   
--   Using VFL is also possible to specify predicates that describe
--   constraints on attributes like width and height:
--   
--   <pre>
--   // Width must be greater than, or equal to 50
--   [button(&gt;=50)]
--   
--   // Width of button1 must be equal to width of button2
--   [button1(==button2)]
--   </pre>
--   
--   The default orientation for a VFL description is horizontal, unless
--   otherwise specified:
--   
--   <pre>
--   // horizontal orientation, default attribute: width
--   H:[button(&gt;=150)]
--   
--   // vertical orientation, default attribute: height
--   V:[button1(==button2)]
--   </pre>
--   
--   It's also possible to specify multiple predicates, as well as their
--   strength:
--   
--   <pre>
--   // minimum width of button must be 150
--   // natural width of button can be 250
--   [button(&gt;=150@required, ==250@medium)]
--   </pre>
--   
--   Finally, it's also possible to use simple arithmetic operators:
--   
--   <pre>
--   // width of button1 must be equal to width of button2
--   // divided by 2 plus 12
--   [button1(button2 / 2 + 12)]
--   </pre>
module GI.Gtk.Objects.ConstraintLayout

-- | Memory-managed wrapper type.
newtype ConstraintLayout
ConstraintLayout :: ManagedPtr ConstraintLayout -> ConstraintLayout

-- | Type class for types which can be safely cast to
--   <a>ConstraintLayout</a>, for instance with <a>toConstraintLayout</a>.
class (GObject o, IsDescendantOf ConstraintLayout o) => IsConstraintLayout o

-- | Cast to <a>ConstraintLayout</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toConstraintLayout :: (MonadIO m, IsConstraintLayout o) => o -> m ConstraintLayout

-- | Adds a constraint to the layout manager.
--   
--   The <a>Constraint:source</a> and <a>Constraint:target</a> properties
--   of <tt>constraint</tt> can be:
--   
--   <ul>
--   <li>set to <tt>NULL</tt> to indicate that the constraint refers to the
--   widget using <tt>layout</tt></li>
--   <li>set to the <a>Widget</a> using <tt>layout</tt></li>
--   <li>set to a child of the <a>Widget</a> using <tt>layout</tt></li>
--   <li>set to a <a>ConstraintGuide</a> that is part of
--   <tt>layout</tt></li>
--   </ul>
--   
--   The <i><tt>layout</tt></i> acquires the ownership of
--   <i><tt>constraint</tt></i> after calling this function.
constraintLayoutAddConstraint :: (HasCallStack, MonadIO m, IsConstraintLayout a, IsConstraint b) => a -> b -> m ()

-- | Adds a guide to <tt>layout</tt>.
--   
--   A guide can be used as the source or target of constraints, like a
--   widget, but it is not visible.
--   
--   The <tt>layout</tt> acquires the ownership of <tt>guide</tt> after
--   calling this function.
constraintLayoutAddGuide :: (HasCallStack, MonadIO m, IsConstraintLayout a, IsConstraintGuide b) => a -> b -> m ()

-- | Creates a new <tt>GtkConstraintLayout</tt> layout manager.
constraintLayoutNew :: (HasCallStack, MonadIO m) => m ConstraintLayout

-- | Returns a <tt>GListModel</tt> to track the constraints that are part
--   of the layout.
--   
--   Calling this function will enable extra internal bookkeeping to track
--   constraints and emit signals on the returned listmodel. It may slow
--   down operations a lot.
--   
--   Applications should try hard to avoid calling this function because of
--   the slowdowns.
constraintLayoutObserveConstraints :: (HasCallStack, MonadIO m, IsConstraintLayout a) => a -> m ListModel

-- | Returns a <tt>GListModel</tt> to track the guides that are part of the
--   layout.
--   
--   Calling this function will enable extra internal bookkeeping to track
--   guides and emit signals on the returned listmodel. It may slow down
--   operations a lot.
--   
--   Applications should try hard to avoid calling this function because of
--   the slowdowns.
constraintLayoutObserveGuides :: (HasCallStack, MonadIO m, IsConstraintLayout a) => a -> m ListModel

-- | Removes all constraints from the layout manager.
constraintLayoutRemoveAllConstraints :: (HasCallStack, MonadIO m, IsConstraintLayout a) => a -> m ()

-- | Removes <tt>constraint</tt> from the layout manager, so that it no
--   longer influences the layout.
constraintLayoutRemoveConstraint :: (HasCallStack, MonadIO m, IsConstraintLayout a, IsConstraint b) => a -> b -> m ()

-- | Removes <tt>guide</tt> from the layout manager, so that it no longer
--   influences the layout.
constraintLayoutRemoveGuide :: (HasCallStack, MonadIO m, IsConstraintLayout a, IsConstraintGuide b) => a -> b -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ConstraintLayout.ConstraintLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ConstraintLayout.ConstraintLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ConstraintLayout.ConstraintLayout
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ConstraintLayout.ConstraintLayout o) => GI.Gtk.Objects.ConstraintLayout.IsConstraintLayout o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ConstraintLayout.ConstraintLayout)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ConstraintLayout.ConstraintLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ConstraintLayout.ConstraintLayout


-- | A constant value in a <tt>GtkExpression</tt>.
module GI.Gtk.Objects.ConstantExpression

-- | Memory-managed wrapper type.
newtype ConstantExpression
ConstantExpression :: ManagedPtr ConstantExpression -> ConstantExpression

-- | Type class for types which can be safely cast to
--   <a>ConstantExpression</a>, for instance with
--   <a>toConstantExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ConstantExpression o) => IsConstantExpression o

-- | Cast to <a>ConstantExpression</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toConstantExpression :: (MonadIO m, IsConstantExpression o) => o -> m ConstantExpression

-- | Gets the value that a constant expression evaluates to.
constantExpressionGetValue :: (HasCallStack, MonadIO m, IsConstantExpression a) => a -> m GValue

-- | Creates an expression that always evaluates to the given
--   <tt>value</tt>.
constantExpressionNewForValue :: (HasCallStack, MonadIO m) => GValue -> m ConstantExpression
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.ConstantExpression.ConstantExpression
instance GHC.Classes.Eq GI.Gtk.Objects.ConstantExpression.ConstantExpression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ConstantExpression.ConstantExpression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ConstantExpression.ConstantExpression o) => GI.Gtk.Objects.ConstantExpression.IsConstantExpression o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ConstantExpression.ConstantExpression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ConstantExpression.ConstantExpression


-- | A <tt>GtkComboBoxText</tt> is a simple variant of <tt>GtkComboBox</tt>
--   for text-only use cases.
--   
--   &lt;picture&gt; &lt;source srcset="combo-box-text-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkComboBoxText" src="combo-box-text.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkComboBoxText</tt> hides the model-view complexity of
--   <tt>GtkComboBox</tt>.
--   
--   To create a <tt>GtkComboBoxText</tt>, use <a>comboBoxTextNew</a> or
--   <a>comboBoxTextNewWithEntry</a>.
--   
--   You can add items to a <tt>GtkComboBoxText</tt> with
--   <a>comboBoxTextAppendText</a>, <a>comboBoxTextInsertText</a> or
--   <a>comboBoxTextPrependText</a> and remove options with
--   <a>comboBoxTextRemove</a>.
--   
--   If the <tt>GtkComboBoxText</tt> contains an entry (via the
--   <a>ComboBox:hasEntry</a> property), its contents can be retrieved
--   using <a>comboBoxTextGetActiveText</a>.
--   
--   You should not call <a>comboBoxSetModel</a> or attempt to pack more
--   cells into this combo box via its <a>CellLayout</a> interface.
--   
--   <h2>GtkComboBoxText as GtkBuildable</h2>
--   
--   The <tt>GtkComboBoxText</tt> implementation of the
--   <tt>GtkBuildable</tt> interface supports adding items directly using
--   the <tt>&lt;items&gt;</tt> element and specifying
--   <tt>&lt;item&gt;</tt> elements for each item. Each
--   <tt>&lt;item&gt;</tt> element can specify the “id” corresponding to
--   the appended text and also supports the regular translation attributes
--   “translatable”, “context” and “comments”.
--   
--   Here is a UI definition fragment specifying <tt>GtkComboBoxText</tt>
--   items:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkComboBoxText"&gt;
--     &lt;items&gt;
--       &lt;item translatable="yes" id="factory"&gt;Factory&lt;/item&gt;
--       &lt;item translatable="yes" id="home"&gt;Home&lt;/item&gt;
--       &lt;item translatable="yes" id="subway"&gt;Subway&lt;/item&gt;
--     &lt;/items&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h2>CSS nodes</h2>
--   
--   <pre>
--   combobox
--   ╰── box.linked
--       ├── entry.combo
--       ├── button.combo
--       ╰── window.popup
--   </pre>
--   
--   <tt>GtkComboBoxText</tt> has a single CSS node with name combobox. It
--   adds the style class .combo to the main CSS nodes of its entry and
--   button children, and the .linked class to the node of its internal
--   box.
module GI.Gtk.Objects.ComboBoxText

-- | Memory-managed wrapper type.
newtype ComboBoxText
ComboBoxText :: ManagedPtr ComboBoxText -> ComboBoxText

-- | Type class for types which can be safely cast to <a>ComboBoxText</a>,
--   for instance with <a>toComboBoxText</a>.
class (GObject o, IsDescendantOf ComboBoxText o) => IsComboBoxText o

-- | Cast to <a>ComboBoxText</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toComboBoxText :: (MonadIO m, IsComboBoxText o) => o -> m ComboBoxText

-- | Appends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>.
--   
--   If <i><tt>id</tt></i> is non-<a>Nothing</a> then it is used as the ID
--   of the row.
--   
--   This is the same as calling <a>comboBoxTextInsert</a> with a position
--   of -1.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextAppend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

-- | Appends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>.
--   
--   This is the same as calling <a>comboBoxTextInsertText</a> with a
--   position of -1.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextAppendText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Text -> m ()

-- | Returns the currently active string in <i><tt>comboBox</tt></i>.
--   
--   If no row is currently selected, <a>Nothing</a> is returned. If
--   <i><tt>comboBox</tt></i> contains an entry, this function will return
--   its contents (which will not necessarily be an item from the list).

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextGetActiveText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> m (Maybe Text)

-- | Inserts <i><tt>text</tt></i> at <i><tt>position</tt></i> in the list
--   of strings stored in <i><tt>comboBox</tt></i>.
--   
--   If <i><tt>id</tt></i> is non-<a>Nothing</a> then it is used as the ID
--   of the row. See <a>ComboBox:idColumn</a>.
--   
--   If <i><tt>position</tt></i> is negative then <i><tt>text</tt></i> is
--   appended.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextInsert :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Maybe Text -> Text -> m ()

-- | Inserts <i><tt>text</tt></i> at <i><tt>position</tt></i> in the list
--   of strings stored in <i><tt>comboBox</tt></i>.
--   
--   If <i><tt>position</tt></i> is negative then <i><tt>text</tt></i> is
--   appended.
--   
--   This is the same as calling <a>comboBoxTextInsert</a> with a
--   <a>Nothing</a> ID string.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextInsertText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> Text -> m ()

-- | Creates a new <tt>GtkComboBoxText</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextNew :: (HasCallStack, MonadIO m) => m ComboBoxText

-- | Creates a new <tt>GtkComboBoxText</tt> with an entry.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextNewWithEntry :: (HasCallStack, MonadIO m) => m ComboBoxText

-- | Prepends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>.
--   
--   If <i><tt>id</tt></i> is non-<a>Nothing</a> then it is used as the ID
--   of the row.
--   
--   This is the same as calling <a>comboBoxTextInsert</a> with a position
--   of 0.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextPrepend :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Maybe Text -> Text -> m ()

-- | Prepends <i><tt>text</tt></i> to the list of strings stored in
--   <i><tt>comboBox</tt></i>.
--   
--   This is the same as calling <a>comboBoxTextInsertText</a> with a
--   position of 0.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextPrependText :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Text -> m ()

-- | Removes the string at <i><tt>position</tt></i> from
--   <i><tt>comboBox</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextRemove :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> Int32 -> m ()

-- | Removes all the text entries from the combo box.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxTextRemoveAll :: (HasCallStack, MonadIO m, IsComboBoxText a) => a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ComboBoxText.ComboBoxText
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ComboBoxText.ComboBoxText
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ComboBoxText.ComboBoxText
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ComboBoxText.ComboBoxText o) => GI.Gtk.Objects.ComboBoxText.IsComboBoxText o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ComboBoxText.ComboBoxText)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ComboBoxText.ComboBoxText
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ComboBoxText.ComboBoxText


-- | A <tt>GtkComboBox</tt> is a widget that allows the user to choose from
--   a list of valid choices.
--   
--   &lt;picture&gt; &lt;source srcset="combo-box-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkComboBox" src="combo-box.png"&gt; &lt;/picture&gt;
--   
--   The <tt>GtkComboBox</tt> displays the selected choice; when activated,
--   the <tt>GtkComboBox</tt> displays a popup which allows the user to
--   make a new choice.
--   
--   The <tt>GtkComboBox</tt> uses the model-view pattern; the list of
--   valid choices is specified in the form of a tree model, and the
--   display of the choices can be adapted to the data in the model by
--   using cell renderers, as you would in a tree view. This is possible
--   since <tt>GtkComboBox</tt> implements the <a>CellLayout</a> interface.
--   The tree model holding the valid choices is not restricted to a flat
--   list, it can be a real tree, and the popup will reflect the tree
--   structure.
--   
--   To allow the user to enter values not in the model, the
--   <a>ComboBox:hasEntry</a> property allows the <tt>GtkComboBox</tt> to
--   contain a <a>Entry</a>. This entry can be accessed by calling
--   <a>comboBoxGetChild</a> on the combo box.
--   
--   For a simple list of textual choices, the model-view API of
--   <tt>GtkComboBox</tt> can be a bit overwhelming. In this case,
--   <a>ComboBoxText</a> offers a simple alternative. Both
--   <tt>GtkComboBox</tt> and <tt>GtkComboBoxText</tt> can contain an
--   entry.
--   
--   <h2>CSS nodes</h2>
--   
--   <pre>
--   combobox
--   ├── box.linked
--   │   ╰── button.combo
--   │       ╰── box
--   │           ├── cellview
--   │           ╰── arrow
--   ╰── window.popup
--   </pre>
--   
--   A normal combobox contains a box with the .linked class, a button with
--   the .combo class and inside those buttons, there are a cellview and an
--   arrow.
--   
--   <pre>
--   combobox
--   ├── box.linked
--   │   ├── entry.combo
--   │   ╰── button.combo
--   │       ╰── box
--   │           ╰── arrow
--   ╰── window.popup
--   </pre>
--   
--   A <tt>GtkComboBox</tt> with an entry has a single CSS node with name
--   combobox. It contains a box with the .linked class. That box contains
--   an entry and a button, both with the .combo class added. The button
--   also contains another node with name arrow.
--   
--   <h2>Accessibility</h2>
--   
--   <tt>GtkComboBox</tt> uses the <a>AccessibleRoleComboBox</a> role.
module GI.Gtk.Objects.ComboBox

-- | Memory-managed wrapper type.
newtype ComboBox
ComboBox :: ManagedPtr ComboBox -> ComboBox

-- | Type class for types which can be safely cast to <a>ComboBox</a>, for
--   instance with <a>toComboBox</a>.
class (GObject o, IsDescendantOf ComboBox o) => IsComboBox o

-- | Cast to <a>ComboBox</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toComboBox :: (MonadIO m, IsComboBox o) => o -> m ComboBox

-- | Returns the index of the currently active item.
--   
--   If the model is a non-flat treemodel, and the active item is not an
--   immediate child of the root of the tree, this function returns
--   <tt>gtk_tree_path_get_indices (path)[0]</tt>, where <tt>path</tt> is
--   the <a>TreePath</a> of the active item.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetActive :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the ID of the active row of <i><tt>comboBox</tt></i>.
--   
--   This value is taken from the active row and the column specified by
--   the <a>ComboBox:idColumn</a> property of <i><tt>comboBox</tt></i> (see
--   <a>comboBoxSetIdColumn</a>).
--   
--   The returned value is an interned string which means that you can
--   compare the pointer by value to other interned strings and that you
--   must not free it.
--   
--   If the <a>ComboBox:idColumn</a> property of <i><tt>comboBox</tt></i>
--   is not set, or if no row is active, or if the active row has a
--   <a>Nothing</a> ID value, then <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Maybe Text)

-- | Sets <i><tt>iter</tt></i> to point to the currently active item.
--   
--   If no item is active, <i><tt>iter</tt></i> is left unchanged.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Bool, TreeIter)

-- | Returns whether the combo box sets the dropdown button sensitive or
--   not when there are no items in the model.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetButtonSensitivity :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m SensitivityType

-- | Gets the child widget of <i><tt>comboBox</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetChild :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Maybe Widget)

-- | Returns the column which <i><tt>comboBox</tt></i> is using to get the
--   strings from to display in the internal entry.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetEntryTextColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns whether the combo box has an entry.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetHasEntry :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Returns the column which <i><tt>comboBox</tt></i> is using to get
--   string IDs for values from.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetIdColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Int32

-- | Returns the <tt>GtkTreeModel</tt> of <i><tt>comboBox</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetModel :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m (Maybe TreeModel)

-- | Gets whether the popup uses a fixed width.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxGetPopupFixedWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m Bool

-- | Creates a new empty <tt>GtkComboBox</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxNew :: (HasCallStack, MonadIO m) => m ComboBox

-- | Creates a new empty <tt>GtkComboBox</tt> with an entry.
--   
--   In order to use a combo box with entry, you need to tell it which
--   column of the model contains the text for the entry by calling
--   <a>comboBoxSetEntryTextColumn</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxNewWithEntry :: (HasCallStack, MonadIO m) => m ComboBox

-- | Creates a new <tt>GtkComboBox</tt> with a model.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxNewWithModel :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m ComboBox

-- | Creates a new empty <tt>GtkComboBox</tt> with an entry and a model.
--   
--   See also <a>comboBoxNewWithEntry</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxNewWithModelAndEntry :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m ComboBox

-- | Hides the menu or dropdown list of <i><tt>comboBox</tt></i>.
--   
--   This function is mostly intended for use by accessibility
--   technologies; applications should have little use for it.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxPopdown :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m ()

-- | Pops up the menu or dropdown list of <i><tt>comboBox</tt></i>.
--   
--   This function is mostly intended for use by accessibility
--   technologies; applications should have little use for it.
--   
--   Before calling this, <i><tt>comboBox</tt></i> must be mapped, or
--   nothing will happen.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxPopup :: (HasCallStack, MonadIO m, IsComboBox a) => a -> m ()

-- | Pops up the menu of <i><tt>comboBox</tt></i>.
--   
--   Note that currently this does not do anything with the device, as it
--   was previously only used for list-mode combo boxes, and those were
--   removed in GTK 4. However, it is retained in case similar
--   functionality is added back later.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxPopupForDevice :: (HasCallStack, MonadIO m, IsComboBox a, IsDevice b) => a -> b -> m ()

-- | Sets the active item of <i><tt>comboBox</tt></i> to be the item at
--   <i><tt>index</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetActive :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Changes the active row of <i><tt>comboBox</tt></i> to the one that has
--   an ID equal to <i><tt>activeId</tt></i>.
--   
--   If <i><tt>activeId</tt></i> is <a>Nothing</a>, the active row is
--   unset. Rows having a <a>Nothing</a> ID string cannot be made active by
--   this function.
--   
--   If the <a>ComboBox:idColumn</a> property of <i><tt>comboBox</tt></i>
--   is unset or if no row has the given ID then the function does nothing
--   and returns <a>False</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetActiveId :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe Text -> m Bool

-- | Sets the current active item to be the one referenced by
--   <i><tt>iter</tt></i>.
--   
--   If <i><tt>iter</tt></i> is <a>Nothing</a>, the active item is unset.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetActiveIter :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe TreeIter -> m ()

-- | Sets whether the dropdown button of the combo box should update its
--   sensitivity depending on the model contents.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetButtonSensitivity :: (HasCallStack, MonadIO m, IsComboBox a) => a -> SensitivityType -> m ()

-- | Sets the child widget of <i><tt>comboBox</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetChild :: (HasCallStack, MonadIO m, IsComboBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the model column which <i><tt>comboBox</tt></i> should use to get
--   strings from to be <i><tt>textColumn</tt></i>.
--   
--   For this column no separate <a>CellRenderer</a> is needed.
--   
--   The column <i><tt>textColumn</tt></i> in the model of
--   <i><tt>comboBox</tt></i> must be of type
--   <tt><i>G_TYPE_STRING</i></tt>.
--   
--   This is only relevant if <i><tt>comboBox</tt></i> has been created
--   with <a>ComboBox:hasEntry</a> as <a>True</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetEntryTextColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the model column which <i><tt>comboBox</tt></i> should use to get
--   string IDs for values from.
--   
--   The column <i><tt>idColumn</tt></i> in the model of
--   <i><tt>comboBox</tt></i> must be of type
--   <tt><i>G_TYPE_STRING</i></tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetIdColumn :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Int32 -> m ()

-- | Sets the model used by <i><tt>comboBox</tt></i> to be
--   <i><tt>model</tt></i>.
--   
--   Will unset a previously set model (if applicable). If model is
--   <a>Nothing</a>, then it will unset the model.
--   
--   Note that this function does not clear the cell renderers, you have to
--   call <a>cellLayoutClear</a> yourself if you need to set up different
--   cell renderers for the new model.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetModel :: (HasCallStack, MonadIO m, IsComboBox a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Specifies whether the popup’s width should be a fixed width.
--   
--   If <i><tt>fixed</tt></i> is <a>True</a>, the popup's width is set to
--   match the allocated width of the combo box.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetPopupFixedWidth :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Bool -> m ()

-- | Sets the row separator function, which is used to determine whether a
--   row should be drawn as a separator.
--   
--   If the row separator function is <a>Nothing</a>, no separators are
--   drawn. This is the default value.

-- | <i>Deprecated: (Since version 4.10)Use <a>DropDown</a></i>
comboBoxSetRowSeparatorFunc :: (HasCallStack, MonadIO m, IsComboBox a) => a -> Maybe TreeViewRowSeparatorFunc -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructComboBoxActive :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #active
--   </pre>
getComboBoxActive :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #active <a>:=</a> value ]
--   </pre>
setComboBoxActive :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>active-id</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #activeId
--   </pre>
clearComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active-id</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxActiveId :: (IsComboBox o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>active-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #activeId
--   </pre>
getComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>active-id</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #activeId <a>:=</a> value ]
--   </pre>
setComboBoxActiveId :: (MonadIO m, IsComboBox o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>button-sensitivity</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructComboBoxButtonSensitivity :: (IsComboBox o, MonadIO m) => SensitivityType -> m (GValueConstruct o)

-- | Get the value of the “<tt>button-sensitivity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #buttonSensitivity
--   </pre>
getComboBoxButtonSensitivity :: (MonadIO m, IsComboBox o) => o -> m SensitivityType

-- | Set the value of the “<tt>button-sensitivity</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #buttonSensitivity <a>:=</a> value ]
--   </pre>
setComboBoxButtonSensitivity :: (MonadIO m, IsComboBox o) => o -> SensitivityType -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearComboBoxChild :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructComboBoxChild :: (IsComboBox o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #child
--   </pre>
getComboBoxChild :: (MonadIO m, IsComboBox o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #child <a>:=</a> value ]
--   </pre>
setComboBoxChild :: (MonadIO m, IsComboBox o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>entry-text-column</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructComboBoxEntryTextColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>entry-text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #entryTextColumn
--   </pre>
getComboBoxEntryTextColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>entry-text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #entryTextColumn <a>:=</a> value ]
--   </pre>
setComboBoxEntryTextColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-entry</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxHasEntry :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #hasEntry
--   </pre>
getComboBoxHasEntry :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxHasFrame :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #hasFrame
--   </pre>
getComboBoxHasFrame :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #hasFrame <a>:=</a> value ]
--   </pre>
setComboBoxHasFrame :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>id-column</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructComboBoxIdColumn :: (IsComboBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>id-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #idColumn
--   </pre>
getComboBoxIdColumn :: (MonadIO m, IsComboBox o) => o -> m Int32

-- | Set the value of the “<tt>id-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #idColumn <a>:=</a> value ]
--   </pre>
setComboBoxIdColumn :: (MonadIO m, IsComboBox o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearComboBoxModel :: (MonadIO m, IsComboBox o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructComboBoxModel :: (IsComboBox o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #model
--   </pre>
getComboBoxModel :: (MonadIO m, IsComboBox o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #model <a>:=</a> value ]
--   </pre>
setComboBoxModel :: (MonadIO m, IsComboBox o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>popup-fixed-width</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructComboBoxPopupFixedWidth :: (IsComboBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>popup-fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #popupFixedWidth
--   </pre>
getComboBoxPopupFixedWidth :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Set the value of the “<tt>popup-fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> comboBox [ #popupFixedWidth <a>:=</a> value ]
--   </pre>
setComboBoxPopupFixedWidth :: (MonadIO m, IsComboBox o) => o -> Bool -> m ()

-- | Get the value of the “<tt>popup-shown</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> comboBox #popupShown
--   </pre>
getComboBoxPopupShown :: (MonadIO m, IsComboBox o) => o -> m Bool

-- | Emitted to when the combo box is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkComboBox</tt> is an action
--   signal and emitting it causes the combo box to pop up its dropdown.
--   
--   <i>Since: 4.6</i>
type ComboBoxActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxActivate :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #activate callback
--   </pre>
onComboBoxActivate :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxActivateCallback) -> m SignalHandlerId

-- | Emitted when the active item is changed.
--   
--   The can be due to the user selecting a different item from the list,
--   or due to a call to <a>comboBoxSetActiveIter</a>. It will also be
--   emitted while typing into the entry of a combo box with an entry.
type ComboBoxChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxChanged :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #changed callback
--   </pre>
onComboBoxChanged :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxChangedCallback) -> m SignalHandlerId

-- | Emitted to allow changing how the text in a combo box's entry is
--   displayed.
--   
--   See <a>ComboBox:hasEntry</a>.
--   
--   Connect a signal handler which returns an allocated string
--   representing <i><tt>path</tt></i>. That string will then be used to
--   set the text in the combo box's entry. The default signal handler uses
--   the text from the <a>ComboBox:entryTextColumn</a> model column.
--   
--   Here's an example signal handler which fetches data from the model and
--   displays it in the entry.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static char *
--   format_entry_text_callback (GtkComboBox *combo,
--                               const char *path,
--                               gpointer     user_data)
--   {
--     GtkTreeIter iter;
--     GtkTreeModel model;
--     double       value;
--   
--     model = gtk_combo_box_get_model (combo);
--   
--     gtk_tree_model_get_iter_from_string (model, &amp;iter, path);
--     gtk_tree_model_get (model, &amp;iter,
--                         THE_DOUBLE_VALUE_COLUMN, &amp;value,
--                         -1);
--   
--     return g_strdup_printf ("%g", value);
--   }
--   </pre>
type ComboBoxFormatEntryTextCallback = Text -> IO Text

-- | Connect a signal handler for the <a>formatEntryText</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #formatEntryText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxFormatEntryText :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxFormatEntryTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>formatEntryText</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #formatEntryText callback
--   </pre>
onComboBoxFormatEntryText :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxFormatEntryTextCallback) -> m SignalHandlerId

-- | Emitted to move the active selection.
--   
--   This is an <a>keybinding signal</a>.
type ComboBoxMoveActiveCallback = ScrollType -> IO ()

-- | Connect a signal handler for the <a>moveActive</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #moveActive callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxMoveActive :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxMoveActiveCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>moveActive</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #moveActive callback
--   </pre>
onComboBoxMoveActive :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxMoveActiveCallback) -> m SignalHandlerId

-- | Emitted to popdown the combo box list.
--   
--   This is an <a>keybinding signal</a>.
--   
--   The default bindings for this signal are Alt+Up and Escape.
type ComboBoxPopdownCallback = IO Bool

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #popdown callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxPopdown :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopdownCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popdown</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #popdown callback
--   </pre>
onComboBoxPopdown :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopdownCallback) -> m SignalHandlerId

-- | Emitted to popup the combo box list.
--   
--   This is an <a>keybinding signal</a>.
--   
--   The default binding for this signal is Alt+Down.
type ComboBoxPopupCallback = IO ()

-- | Connect a signal handler for the <a>popup</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> comboBox #popup callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterComboBoxPopup :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopupCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>popup</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> comboBox #popup callback
--   </pre>
onComboBoxPopup :: (IsComboBox a, MonadIO m) => a -> ((?self :: a) => ComboBoxPopupCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ComboBox.ComboBox
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ComboBox.ComboBox
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ComboBox.ComboBox
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ComboBox.ComboBox o) => GI.Gtk.Objects.ComboBox.IsComboBox o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ComboBox.ComboBox)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ComboBox.ComboBox
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ComboBox.ComboBox


-- | Sorts <a>ColumnView</a> columns.
--   
--   The sorter returned by <a>columnViewGetSorter</a> is a
--   <tt>GtkColumnViewSorter</tt>.
--   
--   In column views, sorting can be configured by associating sorters with
--   columns, and users can invert sort order by clicking on column
--   headers. The API of <tt>GtkColumnViewSorter</tt> is designed to allow
--   saving and restoring this configuration.
--   
--   If you are only interested in the primary sort column (i.e. the column
--   where a sort indicator is shown in the header), then you can just look
--   at <a>ColumnViewSorter:primarySortColumn</a> and
--   <a>ColumnViewSorter:primarySortOrder</a>.
--   
--   If you want to store the full sort configuration, including secondary
--   sort columns that are used for tie breaking, then you can use
--   <a>columnViewSorterGetNthSortColumn</a>. To get notified about
--   changes, use <a>Sorter::changed</a>.
--   
--   To restore a saved sort configuration on a <tt>GtkColumnView</tt>, use
--   code like:
--   
--   <pre>
--   sorter = gtk_column_view_get_sorter (view);
--   for (i = gtk_column_view_sorter_get_n_sort_columns (sorter) - 1; i &gt;= 0; i--)
--     {
--       column = gtk_column_view_sorter_get_nth_sort_column (sorter, i, &amp;order);
--       gtk_column_view_sort_by_column (view, column, order);
--     }
--   </pre>
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.ColumnViewSorter

-- | Memory-managed wrapper type.
newtype ColumnViewSorter
ColumnViewSorter :: ManagedPtr ColumnViewSorter -> ColumnViewSorter

-- | Type class for types which can be safely cast to
--   <a>ColumnViewSorter</a>, for instance with <a>toColumnViewSorter</a>.
class (GObject o, IsDescendantOf ColumnViewSorter o) => IsColumnViewSorter o

-- | Cast to <a>ColumnViewSorter</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toColumnViewSorter :: (MonadIO m, IsColumnViewSorter o) => o -> m ColumnViewSorter

-- | Returns the number of columns by which the sorter sorts.
--   
--   If the sorter of the primary sort column does not determine a total
--   order, then the secondary sorters are consulted to break the ties.
--   
--   Use the <a>Sorter::changed</a> signal to get notified when the number
--   of sort columns changes.
--   
--   <i>Since: 4.10</i>
columnViewSorterGetNSortColumns :: (HasCallStack, MonadIO m, IsColumnViewSorter a) => a -> m Word32

-- | Gets the <i><tt>position</tt></i>'th sort column and its associated
--   sort order.
--   
--   Use the <a>Sorter::changed</a> signal to get notified when sort
--   columns change.
--   
--   <i>Since: 4.10</i>
columnViewSorterGetNthSortColumn :: (HasCallStack, MonadIO m, IsColumnViewSorter a) => a -> Word32 -> m (Maybe ColumnViewColumn, SortType)

-- | Returns the primary sort column.
--   
--   The primary sort column is the one that displays the triangle in a
--   column view header.
--   
--   <i>Since: 4.10</i>
columnViewSorterGetPrimarySortColumn :: (HasCallStack, MonadIO m, IsColumnViewSorter a) => a -> m (Maybe ColumnViewColumn)

-- | Returns the primary sort order.
--   
--   The primary sort order determines whether the triangle displayed in
--   the column view header of the primary sort column points upwards or
--   downwards.
--   
--   If there is no primary sort column, then this function returns
--   <tt>GTK_SORT_ASCENDING</tt>.
--   
--   <i>Since: 4.10</i>
columnViewSorterGetPrimarySortOrder :: (HasCallStack, MonadIO m, IsColumnViewSorter a) => a -> m SortType

-- | Get the value of the “<tt>primary-sort-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewSorter #primarySortColumn
--   </pre>
getColumnViewSorterPrimarySortColumn :: (MonadIO m, IsColumnViewSorter o) => o -> m (Maybe ColumnViewColumn)

-- | Get the value of the “<tt>primary-sort-order</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewSorter #primarySortOrder
--   </pre>
getColumnViewSorterPrimarySortOrder :: (MonadIO m, IsColumnViewSorter o) => o -> m SortType
instance GHC.Classes.Eq GI.Gtk.Objects.ColumnViewSorter.ColumnViewSorter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColumnViewSorter.ColumnViewSorter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColumnViewSorter.ColumnViewSorter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColumnViewSorter.ColumnViewSorter o) => GI.Gtk.Objects.ColumnViewSorter.IsColumnViewSorter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColumnViewSorter.ColumnViewSorter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColumnViewSorter.ColumnViewSorter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColumnViewSorter.ColumnViewSorter


-- | Represents the columns in a <tt>GtkColumnView</tt>.
--   
--   The main ingredient for a <tt>GtkColumnViewColumn</tt> is the
--   <tt>GtkListItemFactory</tt> that tells the columnview how to create
--   cells for this column from items in the model.
--   
--   Columns have a title, and can optionally have a header menu set with
--   <a>columnViewColumnSetHeaderMenu</a>.
--   
--   A sorter can be associated with a column using
--   <a>columnViewColumnSetSorter</a>, to let users influence sorting by
--   clicking on the column header.
module GI.Gtk.Objects.ColumnViewColumn

-- | Memory-managed wrapper type.
newtype ColumnViewColumn
ColumnViewColumn :: ManagedPtr ColumnViewColumn -> ColumnViewColumn

-- | Type class for types which can be safely cast to
--   <a>ColumnViewColumn</a>, for instance with <a>toColumnViewColumn</a>.
class (GObject o, IsDescendantOf ColumnViewColumn o) => IsColumnViewColumn o

-- | Cast to <a>ColumnViewColumn</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toColumnViewColumn :: (MonadIO m, IsColumnViewColumn o) => o -> m ColumnViewColumn

-- | Gets the column view that's currently displaying this column.
--   
--   If <i><tt>self</tt></i> has not been added to a column view yet,
--   <tt>NULL</tt> is returned.
columnViewColumnGetColumnView :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m (Maybe ColumnView)

-- | Returns whether this column should expand.
columnViewColumnGetExpand :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m Bool

-- | Gets the factory that's currently used to populate list items for this
--   column.
columnViewColumnGetFactory :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m (Maybe ListItemFactory)

-- | Gets the fixed width of the column.
columnViewColumnGetFixedWidth :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m Int32

-- | Gets the menu model that is used to create the context menu for the
--   column header.
columnViewColumnGetHeaderMenu :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m (Maybe MenuModel)

-- | Returns the ID set with <a>columnViewColumnSetId</a>.
--   
--   <i>Since: 4.10</i>
columnViewColumnGetId :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m (Maybe Text)

-- | Returns whether this column is resizable.
columnViewColumnGetResizable :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m Bool

-- | Returns the sorter that is associated with the column.
columnViewColumnGetSorter :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m (Maybe Sorter)

-- | Returns the title set with <a>columnViewColumnSetTitle</a>.
columnViewColumnGetTitle :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m (Maybe Text)

-- | Returns whether this column is visible.
columnViewColumnGetVisible :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> m Bool

-- | Creates a new <tt>GtkColumnViewColumn</tt> that uses the given
--   <i><tt>factory</tt></i> for mapping items to widgets.
--   
--   You most likely want to call <a>columnViewAppendColumn</a> next.
--   
--   The function takes ownership of the argument, so you can write code
--   like:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   column = gtk_column_view_column_new (_("Name"),
--     gtk_builder_list_item_factory_new_from_resource ("/name.ui"));
--   </pre>
columnViewColumnNew :: (HasCallStack, MonadIO m, IsListItemFactory a) => Maybe Text -> Maybe a -> m ColumnViewColumn

-- | Sets the column to take available extra space.
--   
--   The extra space is shared equally amongst all columns that have are
--   set to expand.
columnViewColumnSetExpand :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> Bool -> m ()

-- | Sets the <tt>GtkListItemFactory</tt> to use for populating list items
--   for this column.
columnViewColumnSetFactory :: (HasCallStack, MonadIO m, IsColumnViewColumn a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the fixed width of the column.
--   
--   If <i><tt>fixedWidth</tt></i> is -1, the fixed width of the column is
--   unset.
--   
--   Setting a fixed width overrides the automatically calculated width.
--   Interactive resizing also sets the “fixed-width” property.
columnViewColumnSetFixedWidth :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> Int32 -> m ()

-- | Sets the menu model that is used to create the context menu for the
--   column header.
columnViewColumnSetHeaderMenu :: (HasCallStack, MonadIO m, IsColumnViewColumn a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Sets the id of this column.
--   
--   GTK makes no use of this, but applications can use it when storing
--   column view configuration.
--   
--   It is up to callers to ensure uniqueness of IDs.
--   
--   <i>Since: 4.10</i>
columnViewColumnSetId :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> Maybe Text -> m ()

-- | Sets whether this column should be resizable by dragging.
columnViewColumnSetResizable :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> Bool -> m ()

-- | Associates a sorter with the column.
--   
--   If <i><tt>sorter</tt></i> is unset, the column will not let users
--   change the sorting by clicking on its header.
--   
--   This sorter can be made active by clicking on the column header, or by
--   calling <a>columnViewSortByColumn</a>.
--   
--   See <a>columnViewGetSorter</a> for the necessary steps for setting up
--   customizable sorting for <a>ColumnView</a>.
columnViewColumnSetSorter :: (HasCallStack, MonadIO m, IsColumnViewColumn a, IsSorter b) => a -> Maybe b -> m ()

-- | Sets the title of this column.
--   
--   The title is displayed in the header of a <tt>GtkColumnView</tt> for
--   this column and is therefore user-facing text that should be
--   translated.
columnViewColumnSetTitle :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> Maybe Text -> m ()

-- | Sets whether this column should be visible in views.
columnViewColumnSetVisible :: (HasCallStack, MonadIO m, IsColumnViewColumn a) => a -> Bool -> m ()

-- | Get the value of the “<tt>column-view</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #columnView
--   </pre>
getColumnViewColumnColumnView :: (MonadIO m, IsColumnViewColumn o) => o -> m (Maybe ColumnView)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expand</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColumnViewColumnExpand :: (IsColumnViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #expand
--   </pre>
getColumnViewColumnExpand :: (MonadIO m, IsColumnViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>expand</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #expand <a>:=</a> value ]
--   </pre>
setColumnViewColumnExpand :: (MonadIO m, IsColumnViewColumn o) => o -> Bool -> m ()

-- | Set the value of the “<tt>factory</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #factory
--   </pre>
clearColumnViewColumnFactory :: (MonadIO m, IsColumnViewColumn o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>factory</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColumnViewColumnFactory :: (IsColumnViewColumn o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #factory
--   </pre>
getColumnViewColumnFactory :: (MonadIO m, IsColumnViewColumn o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #factory <a>:=</a> value ]
--   </pre>
setColumnViewColumnFactory :: (MonadIO m, IsColumnViewColumn o, IsListItemFactory a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fixed-width</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColumnViewColumnFixedWidth :: (IsColumnViewColumn o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #fixedWidth
--   </pre>
getColumnViewColumnFixedWidth :: (MonadIO m, IsColumnViewColumn o) => o -> m Int32

-- | Set the value of the “<tt>fixed-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #fixedWidth <a>:=</a> value ]
--   </pre>
setColumnViewColumnFixedWidth :: (MonadIO m, IsColumnViewColumn o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>header-menu</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #headerMenu
--   </pre>
clearColumnViewColumnHeaderMenu :: (MonadIO m, IsColumnViewColumn o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>header-menu</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColumnViewColumnHeaderMenu :: (IsColumnViewColumn o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>header-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #headerMenu
--   </pre>
getColumnViewColumnHeaderMenu :: (MonadIO m, IsColumnViewColumn o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>header-menu</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #headerMenu <a>:=</a> value ]
--   </pre>
setColumnViewColumnHeaderMenu :: (MonadIO m, IsColumnViewColumn o, IsMenuModel a) => o -> a -> m ()

-- | Set the value of the “<tt>id</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #id
--   </pre>
clearColumnViewColumnId :: (MonadIO m, IsColumnViewColumn o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>id</tt>” property. This is rarely needed directly, but it is used
--   by <a>new</a>.
constructColumnViewColumnId :: (IsColumnViewColumn o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>id</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #id
--   </pre>
getColumnViewColumnId :: (MonadIO m, IsColumnViewColumn o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>id</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #id <a>:=</a> value ]
--   </pre>
setColumnViewColumnId :: (MonadIO m, IsColumnViewColumn o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resizable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColumnViewColumnResizable :: (IsColumnViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #resizable
--   </pre>
getColumnViewColumnResizable :: (MonadIO m, IsColumnViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>resizable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #resizable <a>:=</a> value ]
--   </pre>
setColumnViewColumnResizable :: (MonadIO m, IsColumnViewColumn o) => o -> Bool -> m ()

-- | Set the value of the “<tt>sorter</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #sorter
--   </pre>
clearColumnViewColumnSorter :: (MonadIO m, IsColumnViewColumn o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sorter</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColumnViewColumnSorter :: (IsColumnViewColumn o, MonadIO m, IsSorter a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #sorter
--   </pre>
getColumnViewColumnSorter :: (MonadIO m, IsColumnViewColumn o) => o -> m (Maybe Sorter)

-- | Set the value of the “<tt>sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #sorter <a>:=</a> value ]
--   </pre>
setColumnViewColumnSorter :: (MonadIO m, IsColumnViewColumn o, IsSorter a) => o -> a -> m ()

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearColumnViewColumnTitle :: (MonadIO m, IsColumnViewColumn o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColumnViewColumnTitle :: (IsColumnViewColumn o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #title
--   </pre>
getColumnViewColumnTitle :: (MonadIO m, IsColumnViewColumn o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #title <a>:=</a> value ]
--   </pre>
setColumnViewColumnTitle :: (MonadIO m, IsColumnViewColumn o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColumnViewColumnVisible :: (IsColumnViewColumn o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewColumn #visible
--   </pre>
getColumnViewColumnVisible :: (MonadIO m, IsColumnViewColumn o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewColumn [ #visible <a>:=</a> value ]
--   </pre>
setColumnViewColumnVisible :: (MonadIO m, IsColumnViewColumn o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ColumnViewColumn.ColumnViewColumn
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColumnViewColumn.ColumnViewColumn
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColumnViewColumn.ColumnViewColumn
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColumnViewColumn.ColumnViewColumn o) => GI.Gtk.Objects.ColumnViewColumn.IsColumnViewColumn o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColumnViewColumn.ColumnViewColumn)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColumnViewColumn.ColumnViewColumn
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColumnViewColumn.ColumnViewColumn


-- | Represents items in a cell in <a>ColumnView</a>.
--   
--   The <tt>GtkColumnViewCell</tt>s are managed by the <a>ColumnView</a>
--   widget (with its factory) and cannot be created by applications, but
--   they need to be populated by application code. This is done by calling
--   <a>columnViewCellSetChild</a>.
--   
--   <tt>GtkColumnViewCell</tt>s exist in 2 stages:
--   
--   <ol>
--   <li>The unbound stage where the listitem is not currently connected to
--   an item in the list. In that case, the <a>ColumnViewCell:item</a>
--   property is set to <a>Nothing</a>.</li>
--   <li>The bound stage where the listitem references an item from the
--   list. The <a>ColumnViewCell:item</a> property is not
--   <a>Nothing</a>.</li>
--   </ol>
--   
--   <i>Since: 4.12</i>
module GI.Gtk.Objects.ColumnViewCell

-- | Memory-managed wrapper type.
newtype ColumnViewCell
ColumnViewCell :: ManagedPtr ColumnViewCell -> ColumnViewCell

-- | Type class for types which can be safely cast to
--   <a>ColumnViewCell</a>, for instance with <a>toColumnViewCell</a>.
class (GObject o, IsDescendantOf ColumnViewCell o) => IsColumnViewCell o

-- | Cast to <a>ColumnViewCell</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColumnViewCell :: (MonadIO m, IsColumnViewCell o) => o -> m ColumnViewCell

-- | Gets the child previously set via <a>columnViewCellSetChild</a> or
--   <a>Nothing</a> if none was set.
--   
--   <i>Since: 4.12</i>
columnViewCellGetChild :: (HasCallStack, MonadIO m, IsColumnViewCell a) => a -> m (Maybe Widget)

-- | Checks if a list item has been set to be focusable via
--   <a>columnViewCellSetFocusable</a>.
--   
--   <i>Since: 4.12</i>
columnViewCellGetFocusable :: (HasCallStack, MonadIO m, IsColumnViewCell a) => a -> m Bool

-- | Gets the model item that associated with <i><tt>self</tt></i>.
--   
--   If <i><tt>self</tt></i> is unbound, this function returns
--   <a>Nothing</a>.
--   
--   <i>Since: 4.12</i>
columnViewCellGetItem :: (HasCallStack, MonadIO m, IsColumnViewCell a) => a -> m (Maybe Object)

-- | Gets the position in the model that <i><tt>self</tt></i> currently
--   displays.
--   
--   If <i><tt>self</tt></i> is unbound, <a>INVALID_LIST_POSITION</a> is
--   returned.
--   
--   <i>Since: 4.12</i>
columnViewCellGetPosition :: (HasCallStack, MonadIO m, IsColumnViewCell a) => a -> m Word32

-- | Checks if the item is displayed as selected.
--   
--   The selected state is maintained by the list widget and its model and
--   cannot be set otherwise.
--   
--   <i>Since: 4.12</i>
columnViewCellGetSelected :: (HasCallStack, MonadIO m, IsColumnViewCell a) => a -> m Bool

-- | Sets the child to be used for this listitem.
--   
--   This function is typically called by applications when setting up a
--   listitem so that the widget can be reused when binding it multiple
--   times.
--   
--   <i>Since: 4.12</i>
columnViewCellSetChild :: (HasCallStack, MonadIO m, IsColumnViewCell a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets <i><tt>self</tt></i> to be focusable.
--   
--   If an item is focusable, it can be focused using the keyboard. This
--   works similar to <a>widgetSetFocusable</a>.
--   
--   Note that if items are not focusable, the keyboard cannot be used to
--   activate them and selecting only works if one of the listitem's
--   children is focusable.
--   
--   By default, list items are focusable.
--   
--   <i>Since: 4.12</i>
columnViewCellSetFocusable :: (HasCallStack, MonadIO m, IsColumnViewCell a) => a -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearColumnViewCellChild :: (MonadIO m, IsColumnViewCell o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColumnViewCellChild :: (IsColumnViewCell o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewCell #child
--   </pre>
getColumnViewCellChild :: (MonadIO m, IsColumnViewCell o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewCell [ #child <a>:=</a> value ]
--   </pre>
setColumnViewCellChild :: (MonadIO m, IsColumnViewCell o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focusable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColumnViewCellFocusable :: (IsColumnViewCell o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewCell #focusable
--   </pre>
getColumnViewCellFocusable :: (MonadIO m, IsColumnViewCell o) => o -> m Bool

-- | Set the value of the “<tt>focusable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnViewCell [ #focusable <a>:=</a> value ]
--   </pre>
setColumnViewCellFocusable :: (MonadIO m, IsColumnViewCell o) => o -> Bool -> m ()

-- | Get the value of the “<tt>item</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewCell #item
--   </pre>
getColumnViewCellItem :: (MonadIO m, IsColumnViewCell o) => o -> m (Maybe Object)

-- | Get the value of the “<tt>position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewCell #position
--   </pre>
getColumnViewCellPosition :: (MonadIO m, IsColumnViewCell o) => o -> m Word32

-- | Get the value of the “<tt>selected</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnViewCell #selected
--   </pre>
getColumnViewCellSelected :: (MonadIO m, IsColumnViewCell o) => o -> m Bool
instance GHC.Classes.Eq GI.Gtk.Objects.ColumnViewCell.ColumnViewCell
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColumnViewCell.ColumnViewCell
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColumnViewCell.ColumnViewCell
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColumnViewCell.ColumnViewCell o) => GI.Gtk.Objects.ColumnViewCell.IsColumnViewCell o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColumnViewCell.ColumnViewCell)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColumnViewCell.ColumnViewCell
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColumnViewCell.ColumnViewCell


-- | Presents a large dynamic list of items using multiple columns with
--   headers.
--   
--   <tt>GtkColumnView</tt> uses the factories of its columns to generate a
--   cell widget for each column, for each visible item and displays them
--   together as the row for this item.
--   
--   The <a>ColumnView:showRowSeparators</a> and
--   <a>ColumnView:showColumnSeparators</a> properties offer a simple way
--   to display separators between the rows or columns.
--   
--   <tt>GtkColumnView</tt> allows the user to select items according to
--   the selection characteristics of the model. For models that allow
--   multiple selected items, it is possible to turn on *rubberband
--   selection*, using <a>ColumnView:enableRubberband</a>.
--   
--   The column view supports sorting that can be customized by the user by
--   clicking on column headers. To set this up, the <tt>GtkSorter</tt>
--   returned by <a>columnViewGetSorter</a> must be attached to a sort
--   model for the data that the view is showing, and the columns must have
--   sorters attached to them by calling <a>columnViewColumnSetSorter</a>.
--   The initial sort order can be set with <a>columnViewSortByColumn</a>.
--   
--   The column view also supports interactive resizing and reordering of
--   columns, via Drag-and-Drop of the column headers. This can be enabled
--   or disabled with the <a>ColumnView:reorderable</a> and
--   <a>ColumnViewColumn:resizable</a> properties.
--   
--   To learn more about the list widget framework, see the
--   <a>overview</a>.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
--   ├── header
--   │   ├── &lt;column header&gt;
--   ┊   ┊
--   │   ╰── &lt;column header&gt;
--   │
--   ├── listview
--   │
--   ┊
--   ╰── [rubberband]
--   </pre>
--   
--   <tt>GtkColumnView</tt> uses a single CSS node named columnview. It may
--   carry the .column-separators style class, when
--   <a>ColumnView:showColumnSeparators</a> property is set. Header widgets
--   appear below a node with name header. The rows are contained in a
--   <tt>GtkListView</tt> widget, so there is a listview node with the same
--   structure as for a standalone <tt>GtkListView</tt> widget. If
--   <a>ColumnView:showRowSeparators</a> is set, it will be passed on to
--   the list view, causing its CSS node to carry the .separators style
--   class. For rubberband selection, a node with name rubberband is used.
--   
--   The main columnview node may also carry style classes to select the
--   style of <a>list presentation</a>: .rich-list, .navigation-sidebar or
--   .data-table.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkColumnView</tt> uses the <a>AccessibleRoleTreeGrid</a> role,
--   header title widgets are using the <a>AccessibleRoleColumnHeader</a>
--   role. The row widgets are using the <a>AccessibleRoleRow</a> role, and
--   individual cells are using the <a>AccessibleRoleGridCell</a> role
module GI.Gtk.Objects.ColumnView

-- | Memory-managed wrapper type.
newtype ColumnView
ColumnView :: ManagedPtr ColumnView -> ColumnView

-- | Type class for types which can be safely cast to <a>ColumnView</a>,
--   for instance with <a>toColumnView</a>.
class (GObject o, IsDescendantOf ColumnView o) => IsColumnView o

-- | Cast to <a>ColumnView</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColumnView :: (MonadIO m, IsColumnView o) => o -> m ColumnView

-- | Appends the <i><tt>column</tt></i> to the end of the columns in
--   <i><tt>self</tt></i>.
columnViewAppendColumn :: (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) => a -> b -> m ()

-- | Gets the list of columns in this column view.
--   
--   This list is constant over the lifetime of <i><tt>self</tt></i> and
--   can be used to monitor changes to the columns of <i><tt>self</tt></i>
--   by connecting to the <a>ListModel::itemsChanged</a> signal.
columnViewGetColumns :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m ListModel

-- | Returns whether rows can be selected by dragging with the mouse.
columnViewGetEnableRubberband :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m Bool

-- | Gets the factory that's currently used to populate section headers.
--   
--   <i>Since: 4.12</i>
columnViewGetHeaderFactory :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m (Maybe ListItemFactory)

-- | Gets the model that's currently used to read the items displayed.
columnViewGetModel :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m (Maybe SelectionModel)

-- | Returns whether columns are reorderable.
columnViewGetReorderable :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m Bool

-- | Gets the factory set via <a>columnViewSetRowFactory</a>.
--   
--   <i>Since: 4.12</i>
columnViewGetRowFactory :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m (Maybe ListItemFactory)

-- | Returns whether the list should show separators between columns.
columnViewGetShowColumnSeparators :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m Bool

-- | Returns whether the list should show separators between rows.
columnViewGetShowRowSeparators :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m Bool

-- | Returns whether rows will be activated on single click and selected on
--   hover.
columnViewGetSingleClickActivate :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m Bool

-- | Returns a special sorter that reflects the users sorting choices in
--   the column view.
--   
--   To allow users to customizable sorting by clicking on column headers,
--   this sorter needs to be set on the sort model underneath the model
--   that is displayed by the view.
--   
--   See <a>columnViewColumnSetSorter</a> for setting up per-column
--   sorting.
--   
--   Here is an example:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   gtk_column_view_column_set_sorter (column, sorter);
--   gtk_column_view_append_column (view, column);
--   sorter = g_object_ref (gtk_column_view_get_sorter (view)));
--   model = gtk_sort_list_model_new (store, sorter);
--   selection = gtk_no_selection_new (model);
--   gtk_column_view_set_model (view, selection);
--   </pre>
columnViewGetSorter :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m (Maybe Sorter)

-- | Gets the behavior set for the &lt;kbd&gt;Tab&lt;/kbd&gt; key.
--   
--   <i>Since: 4.12</i>
columnViewGetTabBehavior :: (HasCallStack, MonadIO m, IsColumnView a) => a -> m ListTabBehavior

-- | Inserts a column at the given position in the columns of
--   <i><tt>self</tt></i>.
--   
--   If <i><tt>column</tt></i> is already a column of <i><tt>self</tt></i>,
--   it will be repositioned.
columnViewInsertColumn :: (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) => a -> Word32 -> b -> m ()

-- | Creates a new <tt>GtkColumnView</tt>.
--   
--   You most likely want to call <a>columnViewAppendColumn</a> to add
--   columns next.
columnViewNew :: (HasCallStack, MonadIO m, IsSelectionModel a) => Maybe a -> m ColumnView

-- | Removes the <i><tt>column</tt></i> from the list of columns of
--   <i><tt>self</tt></i>.
columnViewRemoveColumn :: (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) => a -> b -> m ()

-- | Scroll to the row at the given position - or cell if a column is given
--   - and performs the actions specified in <i><tt>flags</tt></i>.
--   
--   This function works no matter if the columnview is shown or focused.
--   If it isn't, then the changes will take effect once that happens.
--   
--   <i>Since: 4.12</i>
columnViewScrollTo :: (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) => a -> Word32 -> Maybe b -> [ListScrollFlags] -> Maybe ScrollInfo -> m ()

-- | Sets whether selections can be changed by dragging with the mouse.
columnViewSetEnableRubberband :: (HasCallStack, MonadIO m, IsColumnView a) => a -> Bool -> m ()

-- | Sets the factory to use for populating the <a>ListHeader</a> objects
--   used in section headers.
--   
--   If this factory is set to <tt>NULL</tt>, the list will not show
--   section headers.
--   
--   <i>Since: 4.12</i>
columnViewSetHeaderFactory :: (HasCallStack, MonadIO m, IsColumnView a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets the model to use.
--   
--   This must be a <a>SelectionModel</a>.
columnViewSetModel :: (HasCallStack, MonadIO m, IsColumnView a, IsSelectionModel b) => a -> Maybe b -> m ()

-- | Sets whether columns should be reorderable by dragging.
columnViewSetReorderable :: (HasCallStack, MonadIO m, IsColumnView a) => a -> Bool -> m ()

-- | Sets the factory used for configuring rows.
--   
--   The factory must be for configuring <a>ColumnViewRow</a> objects.
--   
--   If this factory is not set - which is the default - then the defaults
--   will be used.
--   
--   This factory is not used to set the widgets displayed in the
--   individual cells. For that see
--   [method<i><tt>gtkColumnViewColumn</tt></i>.set_factory] and
--   [class<i><tt>gtkColumnViewCell</tt></i>].
--   
--   <i>Since: 4.12</i>
columnViewSetRowFactory :: (HasCallStack, MonadIO m, IsColumnView a, IsListItemFactory b) => a -> Maybe b -> m ()

-- | Sets whether the list should show separators between columns.
columnViewSetShowColumnSeparators :: (HasCallStack, MonadIO m, IsColumnView a) => a -> Bool -> m ()

-- | Sets whether the list should show separators between rows.
columnViewSetShowRowSeparators :: (HasCallStack, MonadIO m, IsColumnView a) => a -> Bool -> m ()

-- | Sets whether rows should be activated on single click and selected on
--   hover.
columnViewSetSingleClickActivate :: (HasCallStack, MonadIO m, IsColumnView a) => a -> Bool -> m ()

-- | Sets the &lt;kbd&gt;Tab&lt;/kbd&gt; key behavior.
--   
--   This influences how the &lt;kbd&gt;Tab&lt;/kbd&gt; and
--   &lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;Tab&lt;/kbd&gt; keys move the
--   focus in the columnview.
--   
--   <i>Since: 4.12</i>
columnViewSetTabBehavior :: (HasCallStack, MonadIO m, IsColumnView a) => a -> ListTabBehavior -> m ()

-- | Sets the sorting of the view.
--   
--   This function should be used to set up the initial sorting. At
--   runtime, users can change the sorting of a column view by clicking on
--   the list headers.
--   
--   This call only has an effect if the sorter returned by
--   <a>columnViewGetSorter</a> is set on a sort model, and
--   <a>columnViewColumnSetSorter</a> has been called on
--   <i><tt>column</tt></i> to associate a sorter with the column.
--   
--   If <i><tt>column</tt></i> is unset, the view will be unsorted.
columnViewSortByColumn :: (HasCallStack, MonadIO m, IsColumnView a, IsColumnViewColumn b) => a -> Maybe b -> SortType -> m ()

-- | Get the value of the “<tt>columns</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #columns
--   </pre>
getColumnViewColumns :: (MonadIO m, IsColumnView o) => o -> m ListModel

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-rubberband</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructColumnViewEnableRubberband :: (IsColumnView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-rubberband</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #enableRubberband
--   </pre>
getColumnViewEnableRubberband :: (MonadIO m, IsColumnView o) => o -> m Bool

-- | Set the value of the “<tt>enable-rubberband</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #enableRubberband <a>:=</a> value ]
--   </pre>
setColumnViewEnableRubberband :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()

-- | Set the value of the “<tt>header-factory</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #headerFactory
--   </pre>
clearColumnViewHeaderFactory :: (MonadIO m, IsColumnView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>header-factory</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructColumnViewHeaderFactory :: (IsColumnView o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>header-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #headerFactory
--   </pre>
getColumnViewHeaderFactory :: (MonadIO m, IsColumnView o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>header-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #headerFactory <a>:=</a> value ]
--   </pre>
setColumnViewHeaderFactory :: (MonadIO m, IsColumnView o, IsListItemFactory a) => o -> a -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearColumnViewModel :: (MonadIO m, IsColumnView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColumnViewModel :: (IsColumnView o, MonadIO m, IsSelectionModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #model
--   </pre>
getColumnViewModel :: (MonadIO m, IsColumnView o) => o -> m (Maybe SelectionModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #model <a>:=</a> value ]
--   </pre>
setColumnViewModel :: (MonadIO m, IsColumnView o, IsSelectionModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>reorderable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColumnViewReorderable :: (IsColumnView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #reorderable
--   </pre>
getColumnViewReorderable :: (MonadIO m, IsColumnView o) => o -> m Bool

-- | Set the value of the “<tt>reorderable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #reorderable <a>:=</a> value ]
--   </pre>
setColumnViewReorderable :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()

-- | Set the value of the “<tt>row-factory</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #rowFactory
--   </pre>
clearColumnViewRowFactory :: (MonadIO m, IsColumnView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>row-factory</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColumnViewRowFactory :: (IsColumnView o, MonadIO m, IsListItemFactory a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>row-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #rowFactory
--   </pre>
getColumnViewRowFactory :: (MonadIO m, IsColumnView o) => o -> m (Maybe ListItemFactory)

-- | Set the value of the “<tt>row-factory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #rowFactory <a>:=</a> value ]
--   </pre>
setColumnViewRowFactory :: (MonadIO m, IsColumnView o, IsListItemFactory a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-column-separators</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructColumnViewShowColumnSeparators :: (IsColumnView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-column-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #showColumnSeparators
--   </pre>
getColumnViewShowColumnSeparators :: (MonadIO m, IsColumnView o) => o -> m Bool

-- | Set the value of the “<tt>show-column-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #showColumnSeparators <a>:=</a> value ]
--   </pre>
setColumnViewShowColumnSeparators :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-row-separators</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructColumnViewShowRowSeparators :: (IsColumnView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-row-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #showRowSeparators
--   </pre>
getColumnViewShowRowSeparators :: (MonadIO m, IsColumnView o) => o -> m Bool

-- | Set the value of the “<tt>show-row-separators</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #showRowSeparators <a>:=</a> value ]
--   </pre>
setColumnViewShowRowSeparators :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>single-click-activate</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructColumnViewSingleClickActivate :: (IsColumnView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>single-click-activate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #singleClickActivate
--   </pre>
getColumnViewSingleClickActivate :: (MonadIO m, IsColumnView o) => o -> m Bool

-- | Set the value of the “<tt>single-click-activate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #singleClickActivate <a>:=</a> value ]
--   </pre>
setColumnViewSingleClickActivate :: (MonadIO m, IsColumnView o) => o -> Bool -> m ()

-- | Get the value of the “<tt>sorter</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #sorter
--   </pre>
getColumnViewSorter :: (MonadIO m, IsColumnView o) => o -> m (Maybe Sorter)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>tab-behavior</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColumnViewTabBehavior :: (IsColumnView o, MonadIO m) => ListTabBehavior -> m (GValueConstruct o)

-- | Get the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> columnView #tabBehavior
--   </pre>
getColumnViewTabBehavior :: (MonadIO m, IsColumnView o) => o -> m ListTabBehavior

-- | Set the value of the “<tt>tab-behavior</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> columnView [ #tabBehavior <a>:=</a> value ]
--   </pre>
setColumnViewTabBehavior :: (MonadIO m, IsColumnView o) => o -> ListTabBehavior -> m ()

-- | Emitted when a row has been activated by the user, usually via
--   activating the GtkListBase|list.activate-item action.
--   
--   This allows for a convenient way to handle activation in a columnview.
--   See <a>listItemSetActivatable</a> for details on how to use this
--   signal.
type ColumnViewActivateCallback = Word32 -> IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> columnView #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColumnViewActivate :: (IsColumnView a, MonadIO m) => a -> ((?self :: a) => ColumnViewActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> columnView #activate callback
--   </pre>
onColumnViewActivate :: (IsColumnView a, MonadIO m) => a -> ((?self :: a) => ColumnViewActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ColumnView.ColumnView
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColumnView.ColumnView
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColumnView.ColumnView
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColumnView.ColumnView o) => GI.Gtk.Objects.ColumnView.IsColumnView o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColumnView.ColumnView)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColumnView.ColumnView
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColumnView.ColumnView


-- | Opens a color chooser dialog to select a color.
--   
--   &lt;picture&gt; &lt;source srcset="color-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkColorDialogButton" src="color-button.png"&gt; &lt;/picture&gt;
--   
--   It is suitable widget for selecting a color in a preference dialog.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   colorbutton
--   ╰── button.color
--       ╰── [content]
--   </pre>
--   
--   <tt>GtkColorDialogButton</tt> has a single CSS node with name
--   colorbutton which contains a button node. To differentiate it from a
--   plain <tt>GtkButton</tt>, it gets the .color style class.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.ColorDialogButton

-- | Memory-managed wrapper type.
newtype ColorDialogButton
ColorDialogButton :: ManagedPtr ColorDialogButton -> ColorDialogButton

-- | Type class for types which can be safely cast to
--   <a>ColorDialogButton</a>, for instance with
--   <a>toColorDialogButton</a>.
class (GObject o, IsDescendantOf ColorDialogButton o) => IsColorDialogButton o

-- | Cast to <a>ColorDialogButton</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toColorDialogButton :: (MonadIO m, IsColorDialogButton o) => o -> m ColorDialogButton

-- | Returns the <tt>GtkColorDialog</tt> of <i><tt>self</tt></i>.
--   
--   <i>Since: 4.10</i>
colorDialogButtonGetDialog :: (HasCallStack, MonadIO m, IsColorDialogButton a) => a -> m (Maybe ColorDialog)

-- | Returns the color of the button.
--   
--   This function is what should be used to obtain the color that was
--   chosen by the user. To get informed about changes, listen to
--   "notify<a>rgba</a>".
--   
--   <i>Since: 4.10</i>
colorDialogButtonGetRgba :: (HasCallStack, MonadIO m, IsColorDialogButton a) => a -> m RGBA

-- | Creates a new <tt>GtkColorDialogButton</tt> with the given
--   <tt>GtkColorDialog</tt>.
--   
--   You can pass <tt>NULL</tt> to this function and set a
--   <tt>GtkColorDialog</tt> later. The button will be insensitive until
--   that happens.
--   
--   <i>Since: 4.10</i>
colorDialogButtonNew :: (HasCallStack, MonadIO m, IsColorDialog a) => Maybe a -> m ColorDialogButton

-- | Sets a <tt>GtkColorDialog</tt> object to use for creating the color
--   chooser dialog that is presented when the user clicks the button.
--   
--   <i>Since: 4.10</i>
colorDialogButtonSetDialog :: (HasCallStack, MonadIO m, IsColorDialogButton a, IsColorDialog b) => a -> b -> m ()

-- | Sets the color of the button.
--   
--   <i>Since: 4.10</i>
colorDialogButtonSetRgba :: (HasCallStack, MonadIO m, IsColorDialogButton a) => a -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>dialog</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorDialogButtonDialog :: (IsColorDialogButton o, MonadIO m, IsColorDialog a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>dialog</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorDialogButton #dialog
--   </pre>
getColorDialogButtonDialog :: (MonadIO m, IsColorDialogButton o) => o -> m (Maybe ColorDialog)

-- | Set the value of the “<tt>dialog</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorDialogButton [ #dialog <a>:=</a> value ]
--   </pre>
setColorDialogButtonDialog :: (MonadIO m, IsColorDialogButton o, IsColorDialog a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rgba</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorDialogButtonRgba :: (IsColorDialogButton o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorDialogButton #rgba
--   </pre>
getColorDialogButtonRgba :: (MonadIO m, IsColorDialogButton o) => o -> m RGBA

-- | Set the value of the “<tt>rgba</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorDialogButton [ #rgba <a>:=</a> value ]
--   </pre>
setColorDialogButtonRgba :: (MonadIO m, IsColorDialogButton o) => o -> RGBA -> m ()

-- | Emitted when the color dialog button is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkColorDialogButton</tt> is an
--   action signal and emitting it causes the button to pop up its dialog.
--   
--   <i>Since: 4.14</i>
type ColorDialogButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> colorDialogButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColorDialogButtonActivate :: (IsColorDialogButton a, MonadIO m) => a -> ((?self :: a) => ColorDialogButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> colorDialogButton #activate callback
--   </pre>
onColorDialogButtonActivate :: (IsColorDialogButton a, MonadIO m) => a -> ((?self :: a) => ColorDialogButtonActivateCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ColorDialogButton.ColorDialogButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColorDialogButton.ColorDialogButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColorDialogButton.ColorDialogButton
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColorDialogButton.ColorDialogButton o) => GI.Gtk.Objects.ColorDialogButton.IsColorDialogButton o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColorDialogButton.ColorDialogButton)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColorDialogButton.ColorDialogButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColorDialogButton.ColorDialogButton


-- | Asynchronous API to present a color chooser dialog.
--   
--   <tt>GtkColorDialog</tt> collects the arguments that are needed to
--   present the dialog to the user, such as a title for the dialog and
--   whether it should be modal.
--   
--   The dialog is shown with the <a>colorDialogChooseRgba</a> function.
--   
--   See <a>ColorDialogButton</a> for a convenient control that uses
--   <tt>GtkColorDialog</tt> and presents the results.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.ColorDialog

-- | Memory-managed wrapper type.
newtype ColorDialog
ColorDialog :: ManagedPtr ColorDialog -> ColorDialog

-- | Type class for types which can be safely cast to <a>ColorDialog</a>,
--   for instance with <a>toColorDialog</a>.
class (GObject o, IsDescendantOf ColorDialog o) => IsColorDialog o

-- | Cast to <a>ColorDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColorDialog :: (MonadIO m, IsColorDialog o) => o -> m ColorDialog

-- | Presents a color chooser dialog to the user.
--   
--   <i>Since: 4.10</i>
colorDialogChooseRgba :: (HasCallStack, MonadIO m, IsColorDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe RGBA -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>colorDialogChooseRgba</a> call
--   
--   Note that this function returns a
--   [error<i><tt>gtk</tt></i>.DialogError.DISMISSED] error if the user
--   cancels the dialog.
--   
--   <i>Since: 4.10</i>
colorDialogChooseRgbaFinish :: (HasCallStack, MonadIO m, IsColorDialog a, IsAsyncResult b) => a -> b -> m RGBA

-- | Returns whether the color chooser dialog blocks interaction with the
--   parent window while it is presented.
--   
--   <i>Since: 4.10</i>
colorDialogGetModal :: (HasCallStack, MonadIO m, IsColorDialog a) => a -> m Bool

-- | Returns the title that will be shown on the color chooser dialog.
--   
--   <i>Since: 4.10</i>
colorDialogGetTitle :: (HasCallStack, MonadIO m, IsColorDialog a) => a -> m Text

-- | Returns whether colors may have alpha.
--   
--   <i>Since: 4.10</i>
colorDialogGetWithAlpha :: (HasCallStack, MonadIO m, IsColorDialog a) => a -> m Bool

-- | Creates a new <tt>GtkColorDialog</tt> object.
--   
--   <i>Since: 4.10</i>
colorDialogNew :: (HasCallStack, MonadIO m) => m ColorDialog

-- | Sets whether the color chooser dialog blocks interaction with the
--   parent window while it is presented.
--   
--   <i>Since: 4.10</i>
colorDialogSetModal :: (HasCallStack, MonadIO m, IsColorDialog a) => a -> Bool -> m ()

-- | Sets the title that will be shown on the color chooser dialog.
--   
--   <i>Since: 4.10</i>
colorDialogSetTitle :: (HasCallStack, MonadIO m, IsColorDialog a) => a -> Text -> m ()

-- | Sets whether colors may have alpha.
--   
--   <i>Since: 4.10</i>
colorDialogSetWithAlpha :: (HasCallStack, MonadIO m, IsColorDialog a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorDialogModal :: (IsColorDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorDialog #modal
--   </pre>
getColorDialogModal :: (MonadIO m, IsColorDialog o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorDialog [ #modal <a>:=</a> value ]
--   </pre>
setColorDialogModal :: (MonadIO m, IsColorDialog o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorDialogTitle :: (IsColorDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorDialog #title
--   </pre>
getColorDialogTitle :: (MonadIO m, IsColorDialog o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorDialog [ #title <a>:=</a> value ]
--   </pre>
setColorDialogTitle :: (MonadIO m, IsColorDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>with-alpha</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructColorDialogWithAlpha :: (IsColorDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>with-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorDialog #withAlpha
--   </pre>
getColorDialogWithAlpha :: (MonadIO m, IsColorDialog o) => o -> m Bool

-- | Set the value of the “<tt>with-alpha</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorDialog [ #withAlpha <a>:=</a> value ]
--   </pre>
setColorDialogWithAlpha :: (MonadIO m, IsColorDialog o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ColorDialog.ColorDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColorDialog.ColorDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColorDialog.ColorDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColorDialog.ColorDialog o) => GI.Gtk.Objects.ColorDialog.IsColorDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColorDialog.ColorDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColorDialog.ColorDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColorDialog.ColorDialog


-- | The <tt>GtkColorChooserWidget</tt> widget lets the user select a
--   color.
--   
--   By default, the chooser presents a predefined palette of colors, plus
--   a small number of settable custom colors. It is also possible to
--   select a different color with the single-color editor.
--   
--   To enter the single-color editing mode, use the context menu of any
--   color of the palette, or use the '+' button to add a new custom color.
--   
--   The chooser automatically remembers the last selection, as well as
--   custom colors.
--   
--   To create a <tt>GtkColorChooserWidget</tt>, use
--   <a>colorChooserWidgetNew</a>.
--   
--   To change the initially selected color, use
--   <a>colorChooserSetRgba</a>. To get the selected color use
--   <a>colorChooserGetRgba</a>.
--   
--   The <tt>GtkColorChooserWidget</tt> is used in the
--   <a>ColorChooserDialog</a> to provide a dialog for selecting colors.
--   
--   <h1>Actions</h1>
--   
--   <tt>GtkColorChooserWidget</tt> defines a set of built-in actions:
--   
--   <ul>
--   <li><tt>color.customize</tt> activates the color editor for the given
--   color.</li>
--   <li><tt>color.select</tt> emits the
--   <a>ColorChooser::colorActivated</a> signal for the given color.</li>
--   </ul>
--   
--   <h1>CSS names</h1>
--   
--   <tt>GtkColorChooserWidget</tt> has a single CSS node with name
--   colorchooser.
module GI.Gtk.Objects.ColorChooserWidget

-- | Memory-managed wrapper type.
newtype ColorChooserWidget
ColorChooserWidget :: ManagedPtr ColorChooserWidget -> ColorChooserWidget

-- | Type class for types which can be safely cast to
--   <a>ColorChooserWidget</a>, for instance with
--   <a>toColorChooserWidget</a>.
class (GObject o, IsDescendantOf ColorChooserWidget o) => IsColorChooserWidget o

-- | Cast to <a>ColorChooserWidget</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toColorChooserWidget :: (MonadIO m, IsColorChooserWidget o) => o -> m ColorChooserWidget

-- | Creates a new <tt>GtkColorChooserWidget</tt>.
colorChooserWidgetNew :: (HasCallStack, MonadIO m) => m ColorChooserWidget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-editor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorChooserWidgetShowEditor :: (IsColorChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooserWidget #showEditor
--   </pre>
getColorChooserWidgetShowEditor :: (MonadIO m, IsColorChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooserWidget [ #showEditor <a>:=</a> value ]
--   </pre>
setColorChooserWidgetShowEditor :: (MonadIO m, IsColorChooserWidget o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ColorChooserWidget.ColorChooserWidget
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColorChooserWidget.ColorChooserWidget
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColorChooserWidget.ColorChooserWidget
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColorChooserWidget.ColorChooserWidget o) => GI.Gtk.Objects.ColorChooserWidget.IsColorChooserWidget o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColorChooserWidget.ColorChooserWidget)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColorChooserWidget.ColorChooserWidget
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColorChooserWidget.ColorChooserWidget


-- | A dialog for choosing a color.
--   
--   &lt;picture&gt; &lt;source srcset="colorchooser-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkColorChooserDialog" src="colorchooser.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkColorChooserDialog</tt> implements the <a>ColorChooser</a>
--   interface and does not provide much API of its own.
--   
--   To create a <tt>GtkColorChooserDialog</tt>, use
--   <a>colorChooserDialogNew</a>.
--   
--   To change the initially selected color, use
--   <a>colorChooserSetRgba</a>. To get the selected color use
--   <a>colorChooserGetRgba</a>.
--   
--   <tt>GtkColorChooserDialog</tt> has been deprecated in favor of
--   <a>ColorDialog</a>.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkColorChooserDialog</tt> has a single CSS node with the name
--   <tt>window</tt> and style class <tt>.colorchooser</tt>.
module GI.Gtk.Objects.ColorChooserDialog

-- | Memory-managed wrapper type.
newtype ColorChooserDialog
ColorChooserDialog :: ManagedPtr ColorChooserDialog -> ColorChooserDialog

-- | Type class for types which can be safely cast to
--   <a>ColorChooserDialog</a>, for instance with
--   <a>toColorChooserDialog</a>.
class (GObject o, IsDescendantOf ColorChooserDialog o) => IsColorChooserDialog o

-- | Cast to <a>ColorChooserDialog</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toColorChooserDialog :: (MonadIO m, IsColorChooserDialog o) => o -> m ColorChooserDialog

-- | Creates a new <tt>GtkColorChooserDialog</tt>.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialog</a> instead</i>
colorChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe Text -> Maybe a -> m ColorChooserDialog

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-editor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorChooserDialogShowEditor :: (IsColorChooserDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorChooserDialog #showEditor
--   </pre>
getColorChooserDialogShowEditor :: (MonadIO m, IsColorChooserDialog o) => o -> m Bool

-- | Set the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorChooserDialog [ #showEditor <a>:=</a> value ]
--   </pre>
setColorChooserDialogShowEditor :: (MonadIO m, IsColorChooserDialog o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ColorChooserDialog.ColorChooserDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColorChooserDialog.ColorChooserDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColorChooserDialog.ColorChooserDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColorChooserDialog.ColorChooserDialog o) => GI.Gtk.Objects.ColorChooserDialog.IsColorChooserDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColorChooserDialog.ColorChooserDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColorChooserDialog.ColorChooserDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColorChooserDialog.ColorChooserDialog


-- | The <tt>GtkColorButton</tt> allows to open a color chooser dialog to
--   change the color.
--   
--   &lt;picture&gt; &lt;source srcset="color-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkColorButton" src="color-button.png"&gt; &lt;/picture&gt;
--   
--   It is suitable widget for selecting a color in a preference dialog.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   colorbutton
--   ╰── button.color
--       ╰── [content]
--   </pre>
--   
--   <tt>GtkColorButton</tt> has a single CSS node with name colorbutton
--   which contains a button node. To differentiate it from a plain
--   <tt>GtkButton</tt>, it gets the .color style class.
module GI.Gtk.Objects.ColorButton

-- | Memory-managed wrapper type.
newtype ColorButton
ColorButton :: ManagedPtr ColorButton -> ColorButton

-- | Type class for types which can be safely cast to <a>ColorButton</a>,
--   for instance with <a>toColorButton</a>.
class (GObject o, IsDescendantOf ColorButton o) => IsColorButton o

-- | Cast to <a>ColorButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColorButton :: (MonadIO m, IsColorButton o) => o -> m ColorButton

-- | Gets whether the dialog is modal.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialogButton</a>
--   instead</i>
colorButtonGetModal :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Bool

-- | Gets the title of the color chooser dialog.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialogButton</a>
--   instead</i>
colorButtonGetTitle :: (HasCallStack, MonadIO m, IsColorButton a) => a -> m Text

-- | Creates a new color button.
--   
--   This returns a widget in the form of a small button containing a
--   swatch representing the current selected color. When the button is
--   clicked, a color chooser dialog will open, allowing the user to select
--   a color. The swatch will be updated to reflect the new color when the
--   user finishes.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialogButton</a>
--   instead</i>
colorButtonNew :: (HasCallStack, MonadIO m) => m ColorButton

-- | Creates a new color button showing the given color.
colorButtonNewWithRgba :: (HasCallStack, MonadIO m) => RGBA -> m ColorButton

-- | Sets whether the dialog should be modal.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialogButton</a>
--   instead</i>
colorButtonSetModal :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Bool -> m ()

-- | Sets the title for the color chooser dialog.

-- | <i>Deprecated: (Since version 4.10)Use <a>ColorDialogButton</a>
--   instead</i>
colorButtonSetTitle :: (HasCallStack, MonadIO m, IsColorButton a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorButtonModal :: (IsColorButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #modal
--   </pre>
getColorButtonModal :: (MonadIO m, IsColorButton o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #modal <a>:=</a> value ]
--   </pre>
setColorButtonModal :: (MonadIO m, IsColorButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-editor</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructColorButtonShowEditor :: (IsColorButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #showEditor
--   </pre>
getColorButtonShowEditor :: (MonadIO m, IsColorButton o) => o -> m Bool

-- | Set the value of the “<tt>show-editor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #showEditor <a>:=</a> value ]
--   </pre>
setColorButtonShowEditor :: (MonadIO m, IsColorButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructColorButtonTitle :: (IsColorButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorButton #title
--   </pre>
getColorButtonTitle :: (MonadIO m, IsColorButton o) => o -> m Text

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorButton [ #title <a>:=</a> value ]
--   </pre>
setColorButtonTitle :: (MonadIO m, IsColorButton o) => o -> Text -> m ()

-- | Emitted to when the color button is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkMenuButton</tt> is an action
--   signal and emitting it causes the button to pop up its dialog.
--   
--   <i>Since: 4.4</i>
type ColorButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> colorButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColorButtonActivate :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> colorButton #activate callback
--   </pre>
onColorButtonActivate :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonActivateCallback) -> m SignalHandlerId

-- | Emitted when the user selects a color.
--   
--   When handling this signal, use <a>colorChooserGetRgba</a> to find out
--   which color was just selected.
--   
--   Note that this signal is only emitted when the user changes the color.
--   If you need to react to programmatic color changes as well, use the
--   notify<a>rgba</a> signal.
type ColorButtonColorSetCallback = IO ()

-- | Connect a signal handler for the <a>colorSet</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> colorButton #colorSet callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterColorButtonColorSet :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonColorSetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>colorSet</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> colorButton #colorSet callback
--   </pre>
onColorButtonColorSet :: (IsColorButton a, MonadIO m) => a -> ((?self :: a) => ColorButtonColorSetCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.ColorButton.ColorButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ColorButton.ColorButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ColorButton.ColorButton
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ColorButton.ColorButton o) => GI.Gtk.Objects.ColorButton.IsColorButton o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ColorButton.ColorButton)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ColorButton.ColorButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ColorButton.ColorButton


-- | An expression using a custom <tt>GClosure</tt> to compute the value
--   from its parameters.
module GI.Gtk.Objects.ClosureExpression

-- | Memory-managed wrapper type.
newtype ClosureExpression
ClosureExpression :: ManagedPtr ClosureExpression -> ClosureExpression

-- | Type class for types which can be safely cast to
--   <a>ClosureExpression</a>, for instance with
--   <a>toClosureExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ClosureExpression o) => IsClosureExpression o

-- | Cast to <a>ClosureExpression</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toClosureExpression :: (MonadIO m, IsClosureExpression o) => o -> m ClosureExpression

-- | Creates a <tt>GtkExpression</tt> that calls <tt>closure</tt> when it
--   is evaluated.
--   
--   <tt>closure</tt> is called with the <tt>this</tt> object and the
--   results of evaluating the <tt>params</tt> expressions.
closureExpressionNew :: (HasCallStack, MonadIO m) => GType -> GClosure a -> Maybe [Expression] -> m ClosureExpression
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.ClosureExpression.ClosureExpression
instance GHC.Classes.Eq GI.Gtk.Objects.ClosureExpression.ClosureExpression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ClosureExpression.ClosureExpression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ClosureExpression.ClosureExpression o) => GI.Gtk.Objects.ClosureExpression.IsClosureExpression o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ClosureExpression.ClosureExpression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ClosureExpression.ClosureExpression


-- | Places a label next to an indicator.
--   
--   &lt;picture&gt; &lt;source srcset="check-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Example
--   GtkCheckButtons" src="check-button.png"&gt; &lt;/picture&gt;
--   
--   A <tt>GtkCheckButton</tt> is created by calling either
--   <a>checkButtonNew</a> or <a>checkButtonNewWithLabel</a>.
--   
--   The state of a <tt>GtkCheckButton</tt> can be set specifically using
--   <a>checkButtonSetActive</a>, and retrieved using
--   <a>checkButtonGetActive</a>.
--   
--   <h1>Inconsistent state</h1>
--   
--   In addition to "on" and "off", check buttons can be an "in between"
--   state that is neither on nor off. This can be used e.g. when the user
--   has selected a range of elements (such as some text or spreadsheet
--   cells) that are affected by a check button, and the current values in
--   that range are inconsistent.
--   
--   To set a <tt>GtkCheckButton</tt> to inconsistent state, use
--   <a>checkButtonSetInconsistent</a>.
--   
--   <h1>Grouping</h1>
--   
--   Check buttons can be grouped together, to form mutually exclusive
--   groups - only one of the buttons can be toggled at a time, and
--   toggling another one will switch the currently toggled one off.
--   
--   Grouped check buttons use a different indicator, and are commonly
--   referred to as *radio buttons*.
--   
--   &lt;picture&gt; &lt;source srcset="radio-button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Example
--   GtkRadioButtons" src="radio-button.png"&gt; &lt;/picture&gt;
--   
--   To add a <tt>GtkCheckButton</tt> to a group, use
--   <a>checkButtonSetGroup</a>.
--   
--   When the code must keep track of the state of a group of radio
--   buttons, it is recommended to keep track of such state through a
--   stateful <tt>GAction</tt> with a target for each button. Using the
--   <tt>toggled</tt> signals to keep track of the group changes and state
--   is discouraged.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkCheckButton</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;␣&lt;/kbd&gt; or &lt;kbd&gt;Enter&lt;/kbd&gt; activates
--   the button.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   checkbutton[.text-button][.grouped]
--   ├── check
--   ╰── [label]
--   </pre>
--   
--   A <tt>GtkCheckButton</tt> has a main node with name checkbutton. If
--   the <a>CheckButton:label</a> or <a>CheckButton:child</a> properties
--   are set, it contains a child widget. The indicator node is named check
--   when no group is set, and radio if the checkbutton is grouped together
--   with other checkbuttons.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkCheckButton</tt> uses the <a>AccessibleRoleCheckbox</a> role.
module GI.Gtk.Objects.CheckButton

-- | Memory-managed wrapper type.
newtype CheckButton
CheckButton :: ManagedPtr CheckButton -> CheckButton

-- | Type class for types which can be safely cast to <a>CheckButton</a>,
--   for instance with <a>toCheckButton</a>.
class (GObject o, IsDescendantOf CheckButton o) => IsCheckButton o

-- | Cast to <a>CheckButton</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCheckButton :: (MonadIO m, IsCheckButton o) => o -> m CheckButton

-- | Returns whether the check button is active.
checkButtonGetActive :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> m Bool

-- | Gets the child widget of <i><tt>button</tt></i> or <tt>NULL</tt> if
--   [property<i><tt>checkButton</tt></i>:label] is set.
--   
--   <i>Since: 4.8</i>
checkButtonGetChild :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> m (Maybe Widget)

-- | Returns whether the check button is in an inconsistent state.
checkButtonGetInconsistent :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> m Bool

-- | Returns the label of the check button or <tt>NULL</tt> if
--   [property<i><tt>checkButton</tt></i>:child] is set.
checkButtonGetLabel :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> m (Maybe Text)

-- | Returns whether underlines in the label indicate mnemonics.
checkButtonGetUseUnderline :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> m Bool

-- | Creates a new <tt>GtkCheckButton</tt>.
checkButtonNew :: (HasCallStack, MonadIO m) => m CheckButton

-- | Creates a new <tt>GtkCheckButton</tt> with the given text.
checkButtonNewWithLabel :: (HasCallStack, MonadIO m) => Maybe Text -> m CheckButton

-- | Creates a new <tt>GtkCheckButton</tt> with the given text and a
--   mnemonic.
checkButtonNewWithMnemonic :: (HasCallStack, MonadIO m) => Maybe Text -> m CheckButton

-- | Changes the check buttons active state.
checkButtonSetActive :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> Bool -> m ()

-- | Sets the child widget of <i><tt>button</tt></i>.
--   
--   Note that by using this API, you take full responsibility for setting
--   up the proper accessibility label and description information for
--   <i><tt>button</tt></i>. Most likely, you'll either set the
--   accessibility label or description for <i><tt>button</tt></i>
--   explicitly, or you'll set a labelled-by or described-by relations from
--   <i><tt>child</tt></i> to <i><tt>button</tt></i>.
--   
--   <i>Since: 4.8</i>
checkButtonSetChild :: (HasCallStack, MonadIO m, IsCheckButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Adds <i><tt>self</tt></i> to the group of <i><tt>group</tt></i>.
--   
--   In a group of multiple check buttons, only one button can be active at
--   a time. The behavior of a checkbutton in a group is also commonly
--   known as a *radio button*.
--   
--   Setting the group of a check button also changes the css name of the
--   indicator widget's CSS node to 'radio'.
--   
--   Setting up groups in a cycle leads to undefined behavior.
--   
--   Note that the same effect can be achieved via the <a>Actionable</a>
--   API, by using the same action with parameter type and state type 's'
--   for all buttons in the group, and giving each button its own target
--   value.
checkButtonSetGroup :: (HasCallStack, MonadIO m, IsCheckButton a, IsCheckButton b) => a -> Maybe b -> m ()

-- | Sets the <tt>GtkCheckButton</tt> to inconsistent state.
--   
--   You should turn off the inconsistent state again if the user checks
--   the check button. This has to be done manually.
checkButtonSetInconsistent :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> Bool -> m ()

-- | Sets the text of <i><tt>self</tt></i>.
--   
--   If <a>CheckButton:useUnderline</a> is <a>True</a>, an underscore in
--   <i><tt>label</tt></i> is interpreted as mnemonic indicator, see
--   <a>checkButtonSetUseUnderline</a> for details on this behavior.
checkButtonSetLabel :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> Maybe Text -> m ()

-- | Sets whether underlines in the label indicate mnemonics.
--   
--   If <i><tt>setting</tt></i> is <a>True</a>, an underscore character in
--   <i><tt>self</tt></i>'s label indicates a mnemonic accelerator key.
--   This behavior is similar to <a>Label:useUnderline</a>.
checkButtonSetUseUnderline :: (HasCallStack, MonadIO m, IsCheckButton a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCheckButtonActive :: (IsCheckButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkButton #active
--   </pre>
getCheckButtonActive :: (MonadIO m, IsCheckButton o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkButton [ #active <a>:=</a> value ]
--   </pre>
setCheckButtonActive :: (MonadIO m, IsCheckButton o) => o -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearCheckButtonChild :: (MonadIO m, IsCheckButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCheckButtonChild :: (IsCheckButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkButton #child
--   </pre>
getCheckButtonChild :: (MonadIO m, IsCheckButton o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkButton [ #child <a>:=</a> value ]
--   </pre>
setCheckButtonChild :: (MonadIO m, IsCheckButton o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>group</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #group
--   </pre>
clearCheckButtonGroup :: (MonadIO m, IsCheckButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>group</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCheckButtonGroup :: (IsCheckButton o, MonadIO m, IsCheckButton a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>group</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkButton [ #group <a>:=</a> value ]
--   </pre>
setCheckButtonGroup :: (MonadIO m, IsCheckButton o, IsCheckButton a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inconsistent</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCheckButtonInconsistent :: (IsCheckButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkButton #inconsistent
--   </pre>
getCheckButtonInconsistent :: (MonadIO m, IsCheckButton o) => o -> m Bool

-- | Set the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkButton [ #inconsistent <a>:=</a> value ]
--   </pre>
setCheckButtonInconsistent :: (MonadIO m, IsCheckButton o) => o -> Bool -> m ()

-- | Set the value of the “<tt>label</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #label
--   </pre>
clearCheckButtonLabel :: (MonadIO m, IsCheckButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCheckButtonLabel :: (IsCheckButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkButton #label
--   </pre>
getCheckButtonLabel :: (MonadIO m, IsCheckButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkButton [ #label <a>:=</a> value ]
--   </pre>
setCheckButtonLabel :: (MonadIO m, IsCheckButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCheckButtonUseUnderline :: (IsCheckButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkButton #useUnderline
--   </pre>
getCheckButtonUseUnderline :: (MonadIO m, IsCheckButton o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkButton [ #useUnderline <a>:=</a> value ]
--   </pre>
setCheckButtonUseUnderline :: (MonadIO m, IsCheckButton o) => o -> Bool -> m ()

-- | Emitted to when the check button is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkCheckButton</tt> is an action
--   signal and emitting it causes the button to animate press then
--   release.
--   
--   Applications should never connect to this signal, but use the
--   <a>CheckButton::toggled</a> signal.
--   
--   The default bindings for this signal are all forms of the
--   &lt;kbd&gt;␣&lt;/kbd&gt; and &lt;kbd&gt;Enter&lt;/kbd&gt; keys.
--   
--   <i>Since: 4.2</i>
type CheckButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> checkButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCheckButtonActivate :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> checkButton #activate callback
--   </pre>
onCheckButtonActivate :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonActivateCallback) -> m SignalHandlerId

-- | Emitted when the buttons's <a>CheckButton:active</a> property changes.
type CheckButtonToggledCallback = IO ()

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> checkButton #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCheckButtonToggled :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> checkButton #toggled callback
--   </pre>
onCheckButtonToggled :: (IsCheckButton a, MonadIO m) => a -> ((?self :: a) => CheckButtonToggledCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CheckButton.CheckButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CheckButton.CheckButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CheckButton.CheckButton
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CheckButton.CheckButton o) => GI.Gtk.Objects.CheckButton.IsCheckButton o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CheckButton.CheckButton)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CheckButton.CheckButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CheckButton.CheckButton


-- | Manages up to three children.
--   
--   The start widget is allocated at the start of the layout (left in
--   left-to-right locales and right in right-to-left ones), and the end
--   widget at the end.
--   
--   The center widget is centered regarding the full width of the
--   layout's.
module GI.Gtk.Objects.CenterLayout

-- | Memory-managed wrapper type.
newtype CenterLayout
CenterLayout :: ManagedPtr CenterLayout -> CenterLayout

-- | Type class for types which can be safely cast to <a>CenterLayout</a>,
--   for instance with <a>toCenterLayout</a>.
class (GObject o, IsDescendantOf CenterLayout o) => IsCenterLayout o

-- | Cast to <a>CenterLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCenterLayout :: (MonadIO m, IsCenterLayout o) => o -> m CenterLayout

-- | Returns the baseline position of the layout.
centerLayoutGetBaselinePosition :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> m BaselinePosition

-- | Returns the center widget of the layout.
centerLayoutGetCenterWidget :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> m (Maybe Widget)

-- | Returns the end widget of the layout.
centerLayoutGetEndWidget :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> m (Maybe Widget)

-- | Gets the current orienration of the layout manager.
centerLayoutGetOrientation :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> m Orientation

-- | Gets whether <i><tt>self</tt></i> shrinks the center widget after
--   other children.
--   
--   <i>Since: 4.12</i>
centerLayoutGetShrinkCenterLast :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> m Bool

-- | Returns the start widget of the layout.
centerLayoutGetStartWidget :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> m (Maybe Widget)

-- | Creates a new <tt>GtkCenterLayout</tt>.
centerLayoutNew :: (HasCallStack, MonadIO m) => m CenterLayout

-- | Sets the new baseline position of <i><tt>self</tt></i>
centerLayoutSetBaselinePosition :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> BaselinePosition -> m ()

-- | Sets the new center widget of <i><tt>self</tt></i>.
--   
--   To remove the existing center widget, pass <a>Nothing</a>.
centerLayoutSetCenterWidget :: (HasCallStack, MonadIO m, IsCenterLayout a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the new end widget of <i><tt>self</tt></i>.
--   
--   To remove the existing center widget, pass <a>Nothing</a>.
centerLayoutSetEndWidget :: (HasCallStack, MonadIO m, IsCenterLayout a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the orientation of <i><tt>self</tt></i>.
centerLayoutSetOrientation :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> Orientation -> m ()

-- | Sets whether to shrink the center widget after other children.
--   
--   By default, when there's no space to give all three children their
--   natural widths, the start and end widgets start shrinking and the
--   center child keeps natural width until they reach minimum width.
--   
--   If set to <tt>FALSE</tt>, start and end widgets keep natural width and
--   the center widget starts shrinking instead.
--   
--   <i>Since: 4.12</i>
centerLayoutSetShrinkCenterLast :: (HasCallStack, MonadIO m, IsCenterLayout a) => a -> Bool -> m ()

-- | Sets the new start widget of <i><tt>self</tt></i>.
--   
--   To remove the existing start widget, pass <a>Nothing</a>.
centerLayoutSetStartWidget :: (HasCallStack, MonadIO m, IsCenterLayout a, IsWidget b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shrink-center-last</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCenterLayoutShrinkCenterLast :: (IsCenterLayout o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>shrink-center-last</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> centerLayout #shrinkCenterLast
--   </pre>
getCenterLayoutShrinkCenterLast :: (MonadIO m, IsCenterLayout o) => o -> m Bool

-- | Set the value of the “<tt>shrink-center-last</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> centerLayout [ #shrinkCenterLast <a>:=</a> value ]
--   </pre>
setCenterLayoutShrinkCenterLast :: (MonadIO m, IsCenterLayout o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CenterLayout.CenterLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CenterLayout.CenterLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CenterLayout.CenterLayout
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CenterLayout.CenterLayout o) => GI.Gtk.Objects.CenterLayout.IsCenterLayout o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CenterLayout.CenterLayout)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CenterLayout.CenterLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CenterLayout.CenterLayout


-- | Arranges three children in a row, keeping the middle child centered as
--   well as possible.
--   
--   &lt;picture&gt; &lt;source srcset="centerbox-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkCenterBox" src="centerbox.png"&gt; &lt;/picture&gt;
--   
--   To add children to <tt>GtkCenterBox</tt>, use
--   <a>centerBoxSetStartWidget</a>, <a>centerBoxSetCenterWidget</a> and
--   <a>centerBoxSetEndWidget</a>.
--   
--   The sizing and positioning of children can be influenced with the
--   align and expand properties of the children.
--   
--   <h1>GtkCenterBox as GtkBuildable</h1>
--   
--   The <tt>GtkCenterBox</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports placing children in the 3 positions by specifying
--   “start”, “center” or “end” as the “type” attribute of a
--   <tt>&lt;child&gt;</tt> element.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkCenterBox</tt> uses a single CSS node with the name “box”,
--   
--   The first child of the <tt>GtkCenterBox</tt> will be allocated
--   depending on the text direction, i.e. in left-to-right layouts it will
--   be allocated on the left and in right-to-left layouts on the right.
--   
--   In vertical orientation, the nodes of the children are arranged from
--   top to bottom.
--   
--   <h1>Accessibility</h1>
--   
--   Until GTK 4.10, <tt>GtkCenterBox</tt> used the
--   <a>AccessibleRoleGroup</a> role.
--   
--   Starting from GTK 4.12, <tt>GtkCenterBox</tt> uses the
--   <a>AccessibleRoleGeneric</a> role.
module GI.Gtk.Objects.CenterBox

-- | Memory-managed wrapper type.
newtype CenterBox
CenterBox :: ManagedPtr CenterBox -> CenterBox

-- | Type class for types which can be safely cast to <a>CenterBox</a>, for
--   instance with <a>toCenterBox</a>.
class (GObject o, IsDescendantOf CenterBox o) => IsCenterBox o

-- | Cast to <a>CenterBox</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCenterBox :: (MonadIO m, IsCenterBox o) => o -> m CenterBox

-- | Gets the baseline position of the center box.
--   
--   See <a>centerBoxSetBaselinePosition</a>.
centerBoxGetBaselinePosition :: (HasCallStack, MonadIO m, IsCenterBox a) => a -> m BaselinePosition

-- | Gets the center widget.
centerBoxGetCenterWidget :: (HasCallStack, MonadIO m, IsCenterBox a) => a -> m (Maybe Widget)

-- | Gets the end widget.
centerBoxGetEndWidget :: (HasCallStack, MonadIO m, IsCenterBox a) => a -> m (Maybe Widget)

-- | Gets whether the center widget shrinks after other children.
--   
--   <i>Since: 4.12</i>
centerBoxGetShrinkCenterLast :: (HasCallStack, MonadIO m, IsCenterBox a) => a -> m Bool

-- | Gets the start widget.
centerBoxGetStartWidget :: (HasCallStack, MonadIO m, IsCenterBox a) => a -> m (Maybe Widget)

-- | Creates a new <tt>GtkCenterBox</tt>.
centerBoxNew :: (HasCallStack, MonadIO m) => m CenterBox

-- | Sets the baseline position of a center box.
--   
--   This affects only horizontal boxes with at least one baseline aligned
--   child. If there is more vertical space available than requested, and
--   the baseline is not allocated by the parent then
--   <i><tt>position</tt></i> is used to allocate the baseline with respect
--   to the extra space available.
centerBoxSetBaselinePosition :: (HasCallStack, MonadIO m, IsCenterBox a) => a -> BaselinePosition -> m ()

-- | Sets the center widget.
--   
--   To remove the existing center widget, pass <tt>NULL</tt>.
centerBoxSetCenterWidget :: (HasCallStack, MonadIO m, IsCenterBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the end widget.
--   
--   To remove the existing end widget, pass <tt>NULL</tt>.
centerBoxSetEndWidget :: (HasCallStack, MonadIO m, IsCenterBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether to shrink the center widget after other children.
--   
--   By default, when there's no space to give all three children their
--   natural widths, the start and end widgets start shrinking and the
--   center child keeps natural width until they reach minimum width.
--   
--   If <i><tt>shrinkCenterLast</tt></i> is false, start and end widgets
--   keep natural width and the center widget starts shrinking instead.
--   
--   <i>Since: 4.12</i>
centerBoxSetShrinkCenterLast :: (HasCallStack, MonadIO m, IsCenterBox a) => a -> Bool -> m ()

-- | Sets the start widget.
--   
--   To remove the existing start widget, pass <tt>NULL</tt>.
centerBoxSetStartWidget :: (HasCallStack, MonadIO m, IsCenterBox a, IsWidget b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-position</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCenterBoxBaselinePosition :: (IsCenterBox o, MonadIO m) => BaselinePosition -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> centerBox #baselinePosition
--   </pre>
getCenterBoxBaselinePosition :: (MonadIO m, IsCenterBox o) => o -> m BaselinePosition

-- | Set the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> centerBox [ #baselinePosition <a>:=</a> value ]
--   </pre>
setCenterBoxBaselinePosition :: (MonadIO m, IsCenterBox o) => o -> BaselinePosition -> m ()

-- | Set the value of the “<tt>center-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #centerWidget
--   </pre>
clearCenterBoxCenterWidget :: (MonadIO m, IsCenterBox o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>center-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCenterBoxCenterWidget :: (IsCenterBox o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>center-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> centerBox #centerWidget
--   </pre>
getCenterBoxCenterWidget :: (MonadIO m, IsCenterBox o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>center-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> centerBox [ #centerWidget <a>:=</a> value ]
--   </pre>
setCenterBoxCenterWidget :: (MonadIO m, IsCenterBox o, IsWidget a) => o -> a -> m ()

-- | Set the value of the “<tt>end-widget</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #endWidget
--   </pre>
clearCenterBoxEndWidget :: (MonadIO m, IsCenterBox o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>end-widget</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCenterBoxEndWidget :: (IsCenterBox o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>end-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> centerBox #endWidget
--   </pre>
getCenterBoxEndWidget :: (MonadIO m, IsCenterBox o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>end-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> centerBox [ #endWidget <a>:=</a> value ]
--   </pre>
setCenterBoxEndWidget :: (MonadIO m, IsCenterBox o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>shrink-center-last</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCenterBoxShrinkCenterLast :: (IsCenterBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>shrink-center-last</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> centerBox #shrinkCenterLast
--   </pre>
getCenterBoxShrinkCenterLast :: (MonadIO m, IsCenterBox o) => o -> m Bool

-- | Set the value of the “<tt>shrink-center-last</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> centerBox [ #shrinkCenterLast <a>:=</a> value ]
--   </pre>
setCenterBoxShrinkCenterLast :: (MonadIO m, IsCenterBox o) => o -> Bool -> m ()

-- | Set the value of the “<tt>start-widget</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #startWidget
--   </pre>
clearCenterBoxStartWidget :: (MonadIO m, IsCenterBox o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>start-widget</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCenterBoxStartWidget :: (IsCenterBox o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>start-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> centerBox #startWidget
--   </pre>
getCenterBoxStartWidget :: (MonadIO m, IsCenterBox o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>start-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> centerBox [ #startWidget <a>:=</a> value ]
--   </pre>
setCenterBoxStartWidget :: (MonadIO m, IsCenterBox o, IsWidget a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CenterBox.CenterBox
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CenterBox.CenterBox
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CenterBox.CenterBox
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CenterBox.CenterBox o) => GI.Gtk.Objects.CenterBox.IsCenterBox o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CenterBox.CenterBox)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CenterBox.CenterBox
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CenterBox.CenterBox


-- | A widget displaying a single row of a GtkTreeModel
--   
--   A <tt>GtkCellView</tt> displays a single row of a
--   <tt>GtkTreeModel</tt> using a <tt>GtkCellArea</tt> and
--   <tt>GtkCellAreaContext</tt>. A <tt>GtkCellAreaContext</tt> can be
--   provided to the <tt>GtkCellView</tt> at construction time in order to
--   keep the cellview in context of a group of cell views, this ensures
--   that the renderers displayed will be properly aligned with each other
--   (like the aligned cells in the menus of <tt>GtkComboBox</tt>).
--   
--   <tt>GtkCellView</tt> is <tt>GtkOrientable</tt> in order to decide in
--   which orientation the underlying <tt>GtkCellAreaContext</tt> should be
--   allocated. Taking the <tt>GtkComboBox</tt> menu as an example,
--   cellviews should be oriented horizontally if the menus are listed
--   top-to-bottom and thus all share the same width but may have separate
--   individual heights (left-to-right menus should be allocated vertically
--   since they all share the same height but may have variable widths).
--   
--   <h2>CSS nodes</h2>
--   
--   GtkCellView has a single CSS node with name cellview.
module GI.Gtk.Objects.CellView

-- | Memory-managed wrapper type.
newtype CellView
CellView :: ManagedPtr CellView -> CellView

-- | Type class for types which can be safely cast to <a>CellView</a>, for
--   instance with <a>toCellView</a>.
class (GObject o, IsDescendantOf CellView o) => IsCellView o

-- | Cast to <a>CellView</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCellView :: (MonadIO m, IsCellView o) => o -> m CellView

-- | Returns a <tt>GtkTreePath</tt> referring to the currently displayed
--   row. If no row is currently displayed, <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewGetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> m (Maybe TreePath)

-- | Gets whether <i><tt>cellView</tt></i> is configured to draw all of its
--   cells in a sensitive state.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewGetDrawSensitive :: (HasCallStack, MonadIO m, IsCellView a) => a -> m Bool

-- | Gets whether <i><tt>cellView</tt></i> is configured to request space
--   to fit the entire <tt>GtkTreeModel</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewGetFitModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> m Bool

-- | Returns the model for <i><tt>cellView</tt></i>. If no model is used
--   <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewGetModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> m (Maybe TreeModel)

-- | Creates a new <tt>GtkCellView</tt> widget.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewNew :: (HasCallStack, MonadIO m) => m CellView

-- | Creates a new <tt>GtkCellView</tt> widget with a specific
--   <tt>GtkCellArea</tt> to layout cells and a specific
--   <tt>GtkCellAreaContext</tt>.
--   
--   Specifying the same context for a handful of cells lets the underlying
--   area synchronize the geometry for those cells, in this way alignments
--   with cellviews for other rows are possible.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewNewWithContext :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b) => a -> b -> m CellView

-- | Creates a new <tt>GtkCellView</tt> widget, adds a
--   <tt>GtkCellRendererText</tt> to it, and makes it show
--   <i><tt>markup</tt></i>. The text can be marked up with the <a>Pango
--   text markup language</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewNewWithMarkup :: (HasCallStack, MonadIO m) => Text -> m CellView

-- | Creates a new <tt>GtkCellView</tt> widget, adds a
--   <tt>GtkCellRendererText</tt> to it, and makes it show
--   <i><tt>text</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewNewWithText :: (HasCallStack, MonadIO m) => Text -> m CellView

-- | Creates a new <tt>GtkCellView</tt> widget, adds a
--   <tt>GtkCellRendererPixbuf</tt> to it, and makes it show
--   <i><tt>texture</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewNewWithTexture :: (HasCallStack, MonadIO m, IsTexture a) => a -> m CellView

-- | Sets the row of the model that is currently displayed by the
--   <tt>GtkCellView</tt>. If the path is unset, then the contents of the
--   cellview “stick” at their last value; this is not normally a desired
--   result, but may be a needed intermediate state if say, the model for
--   the <tt>GtkCellView</tt> becomes temporarily empty.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewSetDisplayedRow :: (HasCallStack, MonadIO m, IsCellView a) => a -> Maybe TreePath -> m ()

-- | Sets whether <i><tt>cellView</tt></i> should draw all of its cells in
--   a sensitive state, this is used by <tt>GtkComboBox</tt> menus to
--   ensure that rows with insensitive cells that contain children appear
--   sensitive in the parent menu item.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewSetDrawSensitive :: (HasCallStack, MonadIO m, IsCellView a) => a -> Bool -> m ()

-- | Sets whether <i><tt>cellView</tt></i> should request space to fit the
--   entire <tt>GtkTreeModel</tt>.
--   
--   This is used by <tt>GtkComboBox</tt> to ensure that the cell view
--   displayed on the combo box’s button always gets enough space and does
--   not resize when selection changes.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewSetFitModel :: (HasCallStack, MonadIO m, IsCellView a) => a -> Bool -> m ()

-- | Sets the model for <i><tt>cellView</tt></i>. If
--   <i><tt>cellView</tt></i> already has a model set, it will remove it
--   before setting the new model. If <i><tt>model</tt></i> is
--   <a>Nothing</a>, then it will unset the old model.

-- | <i>Deprecated: (Since version 4.10)</i>
cellViewSetModel :: (HasCallStack, MonadIO m, IsCellView a, IsTreeModel b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellViewCellArea :: (IsCellView o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #cellArea
--   </pre>
getCellViewCellArea :: (MonadIO m, IsCellView o) => o -> m (Maybe CellArea)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-area-context</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellViewCellAreaContext :: (IsCellView o, MonadIO m, IsCellAreaContext a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-area-context</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #cellAreaContext
--   </pre>
getCellViewCellAreaContext :: (MonadIO m, IsCellView o) => o -> m (Maybe CellAreaContext)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>draw-sensitive</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellViewDrawSensitive :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>draw-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #drawSensitive
--   </pre>
getCellViewDrawSensitive :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “<tt>draw-sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #drawSensitive <a>:=</a> value ]
--   </pre>
setCellViewDrawSensitive :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fit-model</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellViewFitModel :: (IsCellView o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>fit-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #fitModel
--   </pre>
getCellViewFitModel :: (MonadIO m, IsCellView o) => o -> m Bool

-- | Set the value of the “<tt>fit-model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #fitModel <a>:=</a> value ]
--   </pre>
setCellViewFitModel :: (MonadIO m, IsCellView o) => o -> Bool -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearCellViewModel :: (MonadIO m, IsCellView o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellViewModel :: (IsCellView o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellView #model
--   </pre>
getCellViewModel :: (MonadIO m, IsCellView o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellView [ #model <a>:=</a> value ]
--   </pre>
setCellViewModel :: (MonadIO m, IsCellView o, IsTreeModel a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CellView.CellView
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellView.CellView
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellView.CellView
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellView.CellView o) => GI.Gtk.Objects.CellView.IsCellView o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellView.CellView)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellView.CellView
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellView.CellView


-- | Renders a toggle button in a cell
--   
--   <tt>GtkCellRendererToggle</tt> renders a toggle button in a cell. The
--   button is drawn as a radio or a checkbutton, depending on the
--   <tt>GtkCellRendererToggle:radio</tt> property. When activated, it
--   emits the <tt>GtkCellRendererToggle::toggled</tt> signal.
module GI.Gtk.Objects.CellRendererToggle

-- | Memory-managed wrapper type.
newtype CellRendererToggle
CellRendererToggle :: ManagedPtr CellRendererToggle -> CellRendererToggle

-- | Type class for types which can be safely cast to
--   <a>CellRendererToggle</a>, for instance with
--   <a>toCellRendererToggle</a>.
class (GObject o, IsDescendantOf CellRendererToggle o) => IsCellRendererToggle o

-- | Cast to <a>CellRendererToggle</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererToggle :: (MonadIO m, IsCellRendererToggle o) => o -> m CellRendererToggle

-- | Returns whether the cell renderer is activatable. See
--   <a>cellRendererToggleSetActivatable</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererToggleGetActivatable :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> m Bool

-- | Returns whether the cell renderer is active. See
--   <a>cellRendererToggleSetActive</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererToggleGetActive :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> m Bool

-- | Returns whether we’re rendering radio toggles rather than checkboxes.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererToggleGetRadio :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> m Bool

-- | Creates a new <tt>GtkCellRendererToggle</tt>. Adjust rendering
--   parameters using object properties. Object properties can be set
--   globally (with <tt><i>g_object_set()</i></tt>). Also, with
--   <tt>GtkTreeViewColumn</tt>, you can bind a property to a value in a
--   <tt>GtkTreeModel</tt>. For example, you can bind the “active” property
--   on the cell renderer to a boolean value in the model, thus causing the
--   check button to reflect the state of the model.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererToggleNew :: (HasCallStack, MonadIO m) => m CellRendererToggle

-- | Makes the cell renderer activatable.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererToggleSetActivatable :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | Activates or deactivates a cell renderer.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererToggleSetActive :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | If <i><tt>radio</tt></i> is <a>True</a>, the cell renderer renders a
--   radio toggle (i.e. a toggle in a group of mutually-exclusive toggles).
--   If <a>False</a>, it renders a check toggle (a standalone boolean
--   option). This can be set globally for the cell renderer, or changed
--   just before rendering each cell in the model (for
--   <tt>GtkTreeView</tt>, you set up a per-row setting using
--   <tt>GtkTreeViewColumn</tt> to associate model columns with cell
--   renderer properties).

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererToggleSetRadio :: (HasCallStack, MonadIO m, IsCellRendererToggle a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>activatable</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererToggleActivatable :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #activatable
--   </pre>
getCellRendererToggleActivatable :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>activatable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #activatable <a>:=</a> value ]
--   </pre>
setCellRendererToggleActivatable :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererToggleActive :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #active
--   </pre>
getCellRendererToggleActive :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #active <a>:=</a> value ]
--   </pre>
setCellRendererToggleActive :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inconsistent</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererToggleInconsistent :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #inconsistent
--   </pre>
getCellRendererToggleInconsistent :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>inconsistent</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #inconsistent <a>:=</a> value ]
--   </pre>
setCellRendererToggleInconsistent :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>radio</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererToggleRadio :: (IsCellRendererToggle o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererToggle #radio
--   </pre>
getCellRendererToggleRadio :: (MonadIO m, IsCellRendererToggle o) => o -> m Bool

-- | Set the value of the “<tt>radio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererToggle [ #radio <a>:=</a> value ]
--   </pre>
setCellRendererToggleRadio :: (MonadIO m, IsCellRendererToggle o) => o -> Bool -> m ()

-- | The <a>toggled</a> signal is emitted when the cell is toggled.
--   
--   It is the responsibility of the application to update the model with
--   the correct value to store at <i><tt>path</tt></i>. Often this is
--   simply the opposite of the value currently stored at
--   <i><tt>path</tt></i>.
type CellRendererToggleToggledCallback = Text -> IO ()

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererToggle #toggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>toggled</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererToggle #toggled callback
--   </pre>
onCellRendererToggleToggled :: (IsCellRendererToggle a, MonadIO m) => a -> ((?self :: a) => CellRendererToggleToggledCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererToggle.CellRendererToggle
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererToggle.CellRendererToggle
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererToggle.CellRendererToggle
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererToggle.CellRendererToggle o) => GI.Gtk.Objects.CellRendererToggle.IsCellRendererToggle o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererToggle.CellRendererToggle)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererToggle.CellRendererToggle
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererToggle.CellRendererToggle


-- | Renders text in a cell
--   
--   A <tt>GtkCellRendererText</tt> renders a given text in its cell, using
--   the font, color and style information provided by its properties. The
--   text will be ellipsized if it is too long and the
--   <tt>GtkCellRendererText:ellipsize</tt> property allows it.
--   
--   If the <tt>GtkCellRenderer:mode</tt> is
--   <a>CellRendererModeEditable</a>, the <tt>GtkCellRendererText</tt>
--   allows to edit its text using an entry.
module GI.Gtk.Objects.CellRendererText

-- | Memory-managed wrapper type.
newtype CellRendererText
CellRendererText :: ManagedPtr CellRendererText -> CellRendererText

-- | Type class for types which can be safely cast to
--   <a>CellRendererText</a>, for instance with <a>toCellRendererText</a>.
class (GObject o, IsDescendantOf CellRendererText o) => IsCellRendererText o

-- | Cast to <a>CellRendererText</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererText :: (MonadIO m, IsCellRendererText o) => o -> m CellRendererText

-- | Creates a new <tt>GtkCellRendererText</tt>. Adjust how text is drawn
--   using object properties. Object properties can be set globally (with
--   <tt><i>g_object_set()</i></tt>). Also, with
--   <tt>GtkTreeViewColumn</tt>, you can bind a property to a value in a
--   <tt>GtkTreeModel</tt>. For example, you can bind the “text” property
--   on the cell renderer to a string value in the model, thus rendering a
--   different string in each row of the <tt>GtkTreeView</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererTextNew :: (HasCallStack, MonadIO m) => m CellRendererText

-- | Sets the height of a renderer to explicitly be determined by the
--   “font” and “y_pad” property set on it. Further changes in these
--   properties do not affect the height, so they must be accompanied by a
--   subsequent call to this function. Using this function is inflexible,
--   and should really only be used if calculating the size of a cell is
--   too slow (ie, a massive number of cells displayed). If
--   <i><tt>numberOfRows</tt></i> is -1, then the fixed height is unset,
--   and the height is determined by the properties again.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererTextSetFixedHeightFromFont :: (HasCallStack, MonadIO m, IsCellRendererText a) => a -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>align-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextAlignSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>align-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #alignSet
--   </pre>
getCellRendererTextAlignSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>align-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #alignSet <a>:=</a> value ]
--   </pre>
setCellRendererTextAlignSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>alignment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextAlignment :: (IsCellRendererText o, MonadIO m) => Alignment -> m (GValueConstruct o)

-- | Get the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #alignment
--   </pre>
getCellRendererTextAlignment :: (MonadIO m, IsCellRendererText o) => o -> m Alignment

-- | Set the value of the “<tt>alignment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #alignment <a>:=</a> value ]
--   </pre>
setCellRendererTextAlignment :: (MonadIO m, IsCellRendererText o) => o -> Alignment -> m ()

-- | Set the value of the “<tt>attributes</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #attributes
--   </pre>
clearCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>attributes</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextAttributes :: (IsCellRendererText o, MonadIO m) => AttrList -> m (GValueConstruct o)

-- | Get the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #attributes
--   </pre>
getCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe AttrList)

-- | Set the value of the “<tt>attributes</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #attributes <a>:=</a> value ]
--   </pre>
setCellRendererTextAttributes :: (MonadIO m, IsCellRendererText o) => o -> AttrList -> m ()

-- | Set the value of the “<tt>background</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #background
--   </pre>
clearCellRendererTextBackground :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextBackground :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #background <a>:=</a> value ]
--   </pre>
setCellRendererTextBackground :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Set the value of the “<tt>background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #backgroundRgba
--   </pre>
clearCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextBackgroundRgba :: (IsCellRendererText o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #backgroundRgba
--   </pre>
getCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #backgroundRgba <a>:=</a> value ]
--   </pre>
setCellRendererTextBackgroundRgba :: (MonadIO m, IsCellRendererText o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>background-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextBackgroundSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #backgroundSet
--   </pre>
getCellRendererTextBackgroundSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #backgroundSet <a>:=</a> value ]
--   </pre>
setCellRendererTextBackgroundSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextEditable :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #editable
--   </pre>
getCellRendererTextEditable :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #editable <a>:=</a> value ]
--   </pre>
setCellRendererTextEditable :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextEditableSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #editableSet
--   </pre>
getCellRendererTextEditableSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>editable-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #editableSet <a>:=</a> value ]
--   </pre>
setCellRendererTextEditableSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextEllipsize :: (IsCellRendererText o, MonadIO m) => EllipsizeMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #ellipsize
--   </pre>
getCellRendererTextEllipsize :: (MonadIO m, IsCellRendererText o) => o -> m EllipsizeMode

-- | Set the value of the “<tt>ellipsize</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #ellipsize <a>:=</a> value ]
--   </pre>
setCellRendererTextEllipsize :: (MonadIO m, IsCellRendererText o) => o -> EllipsizeMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ellipsize-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextEllipsizeSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>ellipsize-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #ellipsizeSet
--   </pre>
getCellRendererTextEllipsizeSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>ellipsize-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #ellipsizeSet <a>:=</a> value ]
--   </pre>
setCellRendererTextEllipsizeSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>family</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #family
--   </pre>
clearCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextFamily :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #family
--   </pre>
getCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>family</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #family <a>:=</a> value ]
--   </pre>
setCellRendererTextFamily :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>family-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextFamilySet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #familySet
--   </pre>
getCellRendererTextFamilySet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>family-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #familySet <a>:=</a> value ]
--   </pre>
setCellRendererTextFamilySet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>font</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #font
--   </pre>
clearCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextFont :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #font
--   </pre>
getCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #font <a>:=</a> value ]
--   </pre>
setCellRendererTextFont :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Set the value of the “<tt>font-desc</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #fontDesc
--   </pre>
clearCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-desc</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextFontDesc :: (IsCellRendererText o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #fontDesc
--   </pre>
getCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #fontDesc <a>:=</a> value ]
--   </pre>
setCellRendererTextFontDesc :: (MonadIO m, IsCellRendererText o) => o -> FontDescription -> m ()

-- | Set the value of the “<tt>foreground</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #foreground
--   </pre>
clearCellRendererTextForeground :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextForeground :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>foreground</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #foreground <a>:=</a> value ]
--   </pre>
setCellRendererTextForeground :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Set the value of the “<tt>foreground-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #foregroundRgba
--   </pre>
clearCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-rgba</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextForegroundRgba :: (IsCellRendererText o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #foregroundRgba
--   </pre>
getCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>foreground-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #foregroundRgba <a>:=</a> value ]
--   </pre>
setCellRendererTextForegroundRgba :: (MonadIO m, IsCellRendererText o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>foreground-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextForegroundSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #foregroundSet
--   </pre>
getCellRendererTextForegroundSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>foreground-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #foregroundSet <a>:=</a> value ]
--   </pre>
setCellRendererTextForegroundSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>language</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #language
--   </pre>
clearCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextLanguage :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #language
--   </pre>
getCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #language <a>:=</a> value ]
--   </pre>
setCellRendererTextLanguage :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextLanguageSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #languageSet
--   </pre>
getCellRendererTextLanguageSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>language-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #languageSet <a>:=</a> value ]
--   </pre>
setCellRendererTextLanguageSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>markup</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #markup
--   </pre>
clearCellRendererTextMarkup :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>markup</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextMarkup :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>markup</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #markup <a>:=</a> value ]
--   </pre>
setCellRendererTextMarkup :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width-chars</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextMaxWidthChars :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #maxWidthChars
--   </pre>
getCellRendererTextMaxWidthChars :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #maxWidthChars <a>:=</a> value ]
--   </pre>
setCellRendererTextMaxWidthChars :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>placeholder-text</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #placeholderText
--   </pre>
clearCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>placeholder-text</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextPlaceholderText :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #placeholderText
--   </pre>
getCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>placeholder-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #placeholderText <a>:=</a> value ]
--   </pre>
setCellRendererTextPlaceholderText :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextRise :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #rise
--   </pre>
getCellRendererTextRise :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>rise</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #rise <a>:=</a> value ]
--   </pre>
setCellRendererTextRise :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rise-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextRiseSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #riseSet
--   </pre>
getCellRendererTextRiseSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>rise-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #riseSet <a>:=</a> value ]
--   </pre>
setCellRendererTextRiseSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextScale :: (IsCellRendererText o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #scale
--   </pre>
getCellRendererTextScale :: (MonadIO m, IsCellRendererText o) => o -> m Double

-- | Set the value of the “<tt>scale</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #scale <a>:=</a> value ]
--   </pre>
setCellRendererTextScale :: (MonadIO m, IsCellRendererText o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>scale-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextScaleSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #scaleSet
--   </pre>
getCellRendererTextScaleSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>scale-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #scaleSet <a>:=</a> value ]
--   </pre>
setCellRendererTextScaleSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>single-paragraph-mode</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererTextSingleParagraphMode :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>single-paragraph-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #singleParagraphMode
--   </pre>
getCellRendererTextSingleParagraphMode :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>single-paragraph-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #singleParagraphMode <a>:=</a> value ]
--   </pre>
setCellRendererTextSingleParagraphMode :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextSize :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #size
--   </pre>
getCellRendererTextSize :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #size <a>:=</a> value ]
--   </pre>
setCellRendererTextSize :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-points</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextSizePoints :: (IsCellRendererText o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #sizePoints
--   </pre>
getCellRendererTextSizePoints :: (MonadIO m, IsCellRendererText o) => o -> m Double

-- | Set the value of the “<tt>size-points</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #sizePoints <a>:=</a> value ]
--   </pre>
setCellRendererTextSizePoints :: (MonadIO m, IsCellRendererText o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextSizeSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #sizeSet
--   </pre>
getCellRendererTextSizeSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>size-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #sizeSet <a>:=</a> value ]
--   </pre>
setCellRendererTextSizeSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextStretch :: (IsCellRendererText o, MonadIO m) => Stretch -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #stretch
--   </pre>
getCellRendererTextStretch :: (MonadIO m, IsCellRendererText o) => o -> m Stretch

-- | Set the value of the “<tt>stretch</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #stretch <a>:=</a> value ]
--   </pre>
setCellRendererTextStretch :: (MonadIO m, IsCellRendererText o) => o -> Stretch -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>stretch-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextStretchSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #stretchSet
--   </pre>
getCellRendererTextStretchSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>stretch-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #stretchSet <a>:=</a> value ]
--   </pre>
setCellRendererTextStretchSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextStrikethrough :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #strikethrough
--   </pre>
getCellRendererTextStrikethrough :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #strikethrough <a>:=</a> value ]
--   </pre>
setCellRendererTextStrikethrough :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strikethrough-set</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererTextStrikethroughSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #strikethroughSet
--   </pre>
getCellRendererTextStrikethroughSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>strikethrough-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #strikethroughSet <a>:=</a> value ]
--   </pre>
setCellRendererTextStrikethroughSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextStyle :: (IsCellRendererText o, MonadIO m) => Style -> m (GValueConstruct o)

-- | Get the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #style
--   </pre>
getCellRendererTextStyle :: (MonadIO m, IsCellRendererText o) => o -> m Style

-- | Set the value of the “<tt>style</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #style <a>:=</a> value ]
--   </pre>
setCellRendererTextStyle :: (MonadIO m, IsCellRendererText o) => o -> Style -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>style-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextStyleSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #styleSet
--   </pre>
getCellRendererTextStyleSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>style-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #styleSet <a>:=</a> value ]
--   </pre>
setCellRendererTextStyleSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextText :: (IsCellRendererText o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #text
--   </pre>
getCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #text <a>:=</a> value ]
--   </pre>
setCellRendererTextText :: (MonadIO m, IsCellRendererText o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextUnderline :: (IsCellRendererText o, MonadIO m) => Underline -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #underline
--   </pre>
getCellRendererTextUnderline :: (MonadIO m, IsCellRendererText o) => o -> m Underline

-- | Set the value of the “<tt>underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #underline <a>:=</a> value ]
--   </pre>
setCellRendererTextUnderline :: (MonadIO m, IsCellRendererText o) => o -> Underline -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>underline-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextUnderlineSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #underlineSet
--   </pre>
getCellRendererTextUnderlineSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>underline-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #underlineSet <a>:=</a> value ]
--   </pre>
setCellRendererTextUnderlineSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextVariant :: (IsCellRendererText o, MonadIO m) => Variant -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #variant
--   </pre>
getCellRendererTextVariant :: (MonadIO m, IsCellRendererText o) => o -> m Variant

-- | Set the value of the “<tt>variant</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #variant <a>:=</a> value ]
--   </pre>
setCellRendererTextVariant :: (MonadIO m, IsCellRendererText o) => o -> Variant -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>variant-set</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextVariantSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #variantSet
--   </pre>
getCellRendererTextVariantSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>variant-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #variantSet <a>:=</a> value ]
--   </pre>
setCellRendererTextVariantSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererTextWeight :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #weight
--   </pre>
getCellRendererTextWeight :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>weight</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #weight <a>:=</a> value ]
--   </pre>
setCellRendererTextWeight :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>weight-set</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextWeightSet :: (IsCellRendererText o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #weightSet
--   </pre>
getCellRendererTextWeightSet :: (MonadIO m, IsCellRendererText o) => o -> m Bool

-- | Set the value of the “<tt>weight-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #weightSet <a>:=</a> value ]
--   </pre>
setCellRendererTextWeightSet :: (MonadIO m, IsCellRendererText o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-chars</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererTextWidthChars :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #widthChars
--   </pre>
getCellRendererTextWidthChars :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #widthChars <a>:=</a> value ]
--   </pre>
setCellRendererTextWidthChars :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextWrapMode :: (IsCellRendererText o, MonadIO m) => WrapMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #wrapMode
--   </pre>
getCellRendererTextWrapMode :: (MonadIO m, IsCellRendererText o) => o -> m WrapMode

-- | Set the value of the “<tt>wrap-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #wrapMode <a>:=</a> value ]
--   </pre>
setCellRendererTextWrapMode :: (MonadIO m, IsCellRendererText o) => o -> WrapMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-width</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererTextWrapWidth :: (IsCellRendererText o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererText #wrapWidth
--   </pre>
getCellRendererTextWrapWidth :: (MonadIO m, IsCellRendererText o) => o -> m Int32

-- | Set the value of the “<tt>wrap-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererText [ #wrapWidth <a>:=</a> value ]
--   </pre>
setCellRendererTextWrapWidth :: (MonadIO m, IsCellRendererText o) => o -> Int32 -> m ()

-- | This signal is emitted after <i><tt>renderer</tt></i> has been edited.
--   
--   It is the responsibility of the application to update the model and
--   store <i><tt>newText</tt></i> at the position indicated by
--   <i><tt>path</tt></i>.
type CellRendererTextEditedCallback = Text -> Text -> IO ()

-- | Connect a signal handler for the <a>edited</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererText #edited callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererTextEdited :: (IsCellRendererText a, MonadIO m) => a -> ((?self :: a) => CellRendererTextEditedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>edited</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererText #edited callback
--   </pre>
onCellRendererTextEdited :: (IsCellRendererText a, MonadIO m) => a -> ((?self :: a) => CellRendererTextEditedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererText.CellRendererText
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererText.CellRendererText
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererText.CellRendererText
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererText.CellRendererText o) => GI.Gtk.Objects.CellRendererText.IsCellRendererText o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererText.CellRendererText)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererText.CellRendererText
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererText.CellRendererText


-- | Renders a spinning animation in a cell
--   
--   <tt>GtkCellRendererSpinner</tt> renders a spinning animation in a
--   cell, very similar to <tt>GtkSpinner</tt>. It can often be used as an
--   alternative to a <tt>GtkCellRendererProgress</tt> for displaying
--   indefinite activity, instead of actual progress.
--   
--   To start the animation in a cell, set the
--   <tt>GtkCellRendererSpinner:active</tt> property to <a>True</a> and
--   increment the <tt>GtkCellRendererSpinner:pulse</tt> property at
--   regular intervals. The usual way to set the cell renderer properties
--   for each cell is to bind them to columns in your tree model using e.g.
--   <a>treeViewColumnAddAttribute</a>.
module GI.Gtk.Objects.CellRendererSpinner

-- | Memory-managed wrapper type.
newtype CellRendererSpinner
CellRendererSpinner :: ManagedPtr CellRendererSpinner -> CellRendererSpinner

-- | Type class for types which can be safely cast to
--   <a>CellRendererSpinner</a>, for instance with
--   <a>toCellRendererSpinner</a>.
class (GObject o, IsDescendantOf CellRendererSpinner o) => IsCellRendererSpinner o

-- | Cast to <a>CellRendererSpinner</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererSpinner :: (MonadIO m, IsCellRendererSpinner o) => o -> m CellRendererSpinner

-- | Returns a new cell renderer which will show a spinner to indicate
--   activity.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSpinnerNew :: (HasCallStack, MonadIO m) => m CellRendererSpinner

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>active</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinnerActive :: (IsCellRendererSpinner o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpinner #active
--   </pre>
getCellRendererSpinnerActive :: (MonadIO m, IsCellRendererSpinner o) => o -> m Bool

-- | Set the value of the “<tt>active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpinner [ #active <a>:=</a> value ]
--   </pre>
setCellRendererSpinnerActive :: (MonadIO m, IsCellRendererSpinner o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pulse</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinnerPulse :: (IsCellRendererSpinner o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpinner #pulse
--   </pre>
getCellRendererSpinnerPulse :: (MonadIO m, IsCellRendererSpinner o) => o -> m Word32

-- | Set the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpinner [ #pulse <a>:=</a> value ]
--   </pre>
setCellRendererSpinnerPulse :: (MonadIO m, IsCellRendererSpinner o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>size</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinnerSize :: (IsCellRendererSpinner o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpinner #size
--   </pre>
getCellRendererSpinnerSize :: (MonadIO m, IsCellRendererSpinner o) => o -> m IconSize

-- | Set the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpinner [ #size <a>:=</a> value ]
--   </pre>
setCellRendererSpinnerSize :: (MonadIO m, IsCellRendererSpinner o) => o -> IconSize -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererSpinner.CellRendererSpinner
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererSpinner.CellRendererSpinner
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererSpinner.CellRendererSpinner
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererSpinner.CellRendererSpinner o) => GI.Gtk.Objects.CellRendererSpinner.IsCellRendererSpinner o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererSpinner.CellRendererSpinner)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererSpinner.CellRendererSpinner
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererSpinner.CellRendererSpinner


-- | Renders a spin button in a cell
--   
--   <tt>GtkCellRendererSpin</tt> renders text in a cell like
--   <tt>GtkCellRendererText</tt> from which it is derived. But while
--   <tt>GtkCellRendererText</tt> offers a simple entry to edit the text,
--   <tt>GtkCellRendererSpin</tt> offers a <tt>GtkSpinButton</tt> widget.
--   Of course, that means that the text has to be parseable as a floating
--   point number.
--   
--   The range of the spinbutton is taken from the adjustment property of
--   the cell renderer, which can be set explicitly or mapped to a column
--   in the tree model, like all properties of cell renders.
--   <tt>GtkCellRendererSpin</tt> also has properties for the
--   <tt>GtkCellRendererSpin:climb-rate</tt> and the number of
--   <tt>GtkCellRendererSpin:digits</tt> to display. Other
--   <tt>GtkSpinButton</tt> properties can be set in a handler for the
--   <tt>GtkCellRenderer::editing-started</tt> signal.
module GI.Gtk.Objects.CellRendererSpin

-- | Memory-managed wrapper type.
newtype CellRendererSpin
CellRendererSpin :: ManagedPtr CellRendererSpin -> CellRendererSpin

-- | Type class for types which can be safely cast to
--   <a>CellRendererSpin</a>, for instance with <a>toCellRendererSpin</a>.
class (GObject o, IsDescendantOf CellRendererSpin o) => IsCellRendererSpin o

-- | Cast to <a>CellRendererSpin</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererSpin :: (MonadIO m, IsCellRendererSpin o) => o -> m CellRendererSpin

-- | Creates a new <tt>GtkCellRendererSpin</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSpinNew :: (HasCallStack, MonadIO m) => m CellRendererSpin

-- | Set the value of the “<tt>adjustment</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #adjustment
--   </pre>
clearCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>adjustment</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererSpinAdjustment :: (IsCellRendererSpin o, MonadIO m, IsAdjustment a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpin #adjustment
--   </pre>
getCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o) => o -> m (Maybe Adjustment)

-- | Set the value of the “<tt>adjustment</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpin [ #adjustment <a>:=</a> value ]
--   </pre>
setCellRendererSpinAdjustment :: (MonadIO m, IsCellRendererSpin o, IsAdjustment a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>climb-rate</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererSpinClimbRate :: (IsCellRendererSpin o, MonadIO m) => Double -> m (GValueConstruct o)

-- | Get the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpin #climbRate
--   </pre>
getCellRendererSpinClimbRate :: (MonadIO m, IsCellRendererSpin o) => o -> m Double

-- | Set the value of the “<tt>climb-rate</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpin [ #climbRate <a>:=</a> value ]
--   </pre>
setCellRendererSpinClimbRate :: (MonadIO m, IsCellRendererSpin o) => o -> Double -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>digits</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererSpinDigits :: (IsCellRendererSpin o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererSpin #digits
--   </pre>
getCellRendererSpinDigits :: (MonadIO m, IsCellRendererSpin o) => o -> m Word32

-- | Set the value of the “<tt>digits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererSpin [ #digits <a>:=</a> value ]
--   </pre>
setCellRendererSpinDigits :: (MonadIO m, IsCellRendererSpin o) => o -> Word32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererSpin.CellRendererSpin
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererSpin.CellRendererSpin
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererSpin.CellRendererSpin
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererSpin.CellRendererSpin o) => GI.Gtk.Objects.CellRendererSpin.IsCellRendererSpin o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererSpin.CellRendererSpin)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererSpin.CellRendererSpin
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererSpin.CellRendererSpin


-- | Renders numbers as progress bars
--   
--   <tt>GtkCellRendererProgress</tt> renders a numeric value as a progress
--   par in a cell. Additionally, it can display a text on top of the
--   progress bar.
module GI.Gtk.Objects.CellRendererProgress

-- | Memory-managed wrapper type.
newtype CellRendererProgress
CellRendererProgress :: ManagedPtr CellRendererProgress -> CellRendererProgress

-- | Type class for types which can be safely cast to
--   <a>CellRendererProgress</a>, for instance with
--   <a>toCellRendererProgress</a>.
class (GObject o, IsDescendantOf CellRendererProgress o) => IsCellRendererProgress o

-- | Cast to <a>CellRendererProgress</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererProgress :: (MonadIO m, IsCellRendererProgress o) => o -> m CellRendererProgress

-- | Creates a new <tt>GtkCellRendererProgress</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererProgressNew :: (HasCallStack, MonadIO m) => m CellRendererProgress

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>inverted</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererProgressInverted :: (IsCellRendererProgress o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #inverted
--   </pre>
getCellRendererProgressInverted :: (MonadIO m, IsCellRendererProgress o) => o -> m Bool

-- | Set the value of the “<tt>inverted</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #inverted <a>:=</a> value ]
--   </pre>
setCellRendererProgressInverted :: (MonadIO m, IsCellRendererProgress o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pulse</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererProgressPulse :: (IsCellRendererProgress o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #pulse
--   </pre>
getCellRendererProgressPulse :: (MonadIO m, IsCellRendererProgress o) => o -> m Int32

-- | Set the value of the “<tt>pulse</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #pulse <a>:=</a> value ]
--   </pre>
setCellRendererProgressPulse :: (MonadIO m, IsCellRendererProgress o) => o -> Int32 -> m ()

-- | Set the value of the “<tt>text</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererProgressText :: (IsCellRendererProgress o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #text
--   </pre>
getCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #text <a>:=</a> value ]
--   </pre>
setCellRendererProgressText :: (MonadIO m, IsCellRendererProgress o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-xalign</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererProgressTextXalign :: (IsCellRendererProgress o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #textXalign
--   </pre>
getCellRendererProgressTextXalign :: (MonadIO m, IsCellRendererProgress o) => o -> m Float

-- | Set the value of the “<tt>text-xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #textXalign <a>:=</a> value ]
--   </pre>
setCellRendererProgressTextXalign :: (MonadIO m, IsCellRendererProgress o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-yalign</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererProgressTextYalign :: (IsCellRendererProgress o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #textYalign
--   </pre>
getCellRendererProgressTextYalign :: (MonadIO m, IsCellRendererProgress o) => o -> m Float

-- | Set the value of the “<tt>text-yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #textYalign <a>:=</a> value ]
--   </pre>
setCellRendererProgressTextYalign :: (MonadIO m, IsCellRendererProgress o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>value</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererProgressValue :: (IsCellRendererProgress o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererProgress #value
--   </pre>
getCellRendererProgressValue :: (MonadIO m, IsCellRendererProgress o) => o -> m Int32

-- | Set the value of the “<tt>value</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererProgress [ #value <a>:=</a> value ]
--   </pre>
setCellRendererProgressValue :: (MonadIO m, IsCellRendererProgress o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererProgress.CellRendererProgress
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererProgress.CellRendererProgress
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererProgress.CellRendererProgress
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererProgress.CellRendererProgress o) => GI.Gtk.Objects.CellRendererProgress.IsCellRendererProgress o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererProgress.CellRendererProgress)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererProgress.CellRendererProgress
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererProgress.CellRendererProgress


-- | Renders a pixbuf in a cell
--   
--   A <tt>GtkCellRendererPixbuf</tt> can be used to render an image in a
--   cell. It allows to render either a given <tt>GdkPixbuf</tt> (set via
--   the <tt>GtkCellRendererPixbuf:pixbuf</tt> property) or a named icon
--   (set via the <tt>GtkCellRendererPixbuf:icon-name</tt> property).
--   
--   To support the tree view, <tt>GtkCellRendererPixbuf</tt> also supports
--   rendering two alternative pixbufs, when the
--   <tt>GtkCellRenderer:is-expander</tt> property is <a>True</a>. If the
--   <tt>GtkCellRenderer:is-expanded property</tt> is <a>True</a> and the
--   <tt>GtkCellRendererPixbuf:pixbuf-expander-open</tt> property is set to
--   a pixbuf, it renders that pixbuf, if the
--   <tt>GtkCellRenderer:is-expanded</tt> property is <a>False</a> and the
--   <tt>GtkCellRendererPixbuf:pixbuf-expander-closed</tt> property is set
--   to a pixbuf, it renders that one.
module GI.Gtk.Objects.CellRendererPixbuf

-- | Memory-managed wrapper type.
newtype CellRendererPixbuf
CellRendererPixbuf :: ManagedPtr CellRendererPixbuf -> CellRendererPixbuf

-- | Type class for types which can be safely cast to
--   <a>CellRendererPixbuf</a>, for instance with
--   <a>toCellRendererPixbuf</a>.
class (GObject o, IsDescendantOf CellRendererPixbuf o) => IsCellRendererPixbuf o

-- | Cast to <a>CellRendererPixbuf</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCellRendererPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m CellRendererPixbuf

-- | Creates a new <tt>GtkCellRendererPixbuf</tt>. Adjust rendering
--   parameters using object properties. Object properties can be set
--   globally (with <tt><i>g_object_set()</i></tt>). Also, with
--   <tt>GtkTreeViewColumn</tt>, you can bind a property to a value in a
--   <tt>GtkTreeModel</tt>. For example, you can bind the “pixbuf” property
--   on the cell renderer to a pixbuf value in the model, thus rendering a
--   different image in each row of the <tt>GtkTreeView</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererPixbufNew :: (HasCallStack, MonadIO m) => m CellRendererPixbuf

-- | Set the value of the “<tt>gicon</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #gicon
--   </pre>
clearCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gicon</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererPixbufGicon :: (IsCellRendererPixbuf o, MonadIO m, IsIcon a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #gicon
--   </pre>
getCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Icon)

-- | Set the value of the “<tt>gicon</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #gicon <a>:=</a> value ]
--   </pre>
setCellRendererPixbufGicon :: (MonadIO m, IsCellRendererPixbuf o, IsIcon a) => o -> a -> m ()

-- | Set the value of the “<tt>icon-name</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #iconName
--   </pre>
clearCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererPixbufIconName :: (IsCellRendererPixbuf o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #iconName
--   </pre>
getCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #iconName <a>:=</a> value ]
--   </pre>
setCellRendererPixbufIconName :: (MonadIO m, IsCellRendererPixbuf o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-size</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererPixbufIconSize :: (IsCellRendererPixbuf o, MonadIO m) => IconSize -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #iconSize
--   </pre>
getCellRendererPixbufIconSize :: (MonadIO m, IsCellRendererPixbuf o) => o -> m IconSize

-- | Set the value of the “<tt>icon-size</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #iconSize <a>:=</a> value ]
--   </pre>
setCellRendererPixbufIconSize :: (MonadIO m, IsCellRendererPixbuf o) => o -> IconSize -> m ()

-- | Set the value of the “<tt>pixbuf</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #pixbuf
--   </pre>
clearCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererPixbufPixbuf :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Set the value of the “<tt>pixbuf</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #pixbuf <a>:=</a> value ]
--   </pre>
setCellRendererPixbufPixbuf :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Set the value of the “<tt>pixbuf-expander-closed</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #pixbufExpanderClosed
--   </pre>
clearCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf-expander-closed</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererPixbufPixbufExpanderClosed :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixbuf-expander-closed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #pixbufExpanderClosed
--   </pre>
getCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>pixbuf-expander-closed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #pixbufExpanderClosed <a>:=</a> value ]
--   </pre>
setCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Set the value of the “<tt>pixbuf-expander-open</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #pixbufExpanderOpen
--   </pre>
clearCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pixbuf-expander-open</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererPixbufPixbufExpanderOpen :: (IsCellRendererPixbuf o, MonadIO m, IsPixbuf a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>pixbuf-expander-open</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #pixbufExpanderOpen
--   </pre>
getCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Pixbuf)

-- | Set the value of the “<tt>pixbuf-expander-open</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #pixbufExpanderOpen <a>:=</a> value ]
--   </pre>
setCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, IsCellRendererPixbuf o, IsPixbuf a) => o -> a -> m ()

-- | Set the value of the “<tt>texture</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #texture
--   </pre>
clearCellRendererPixbufTexture :: (MonadIO m, IsCellRendererPixbuf o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>texture</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererPixbufTexture :: (IsCellRendererPixbuf o, MonadIO m, IsTexture a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>texture</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererPixbuf #texture
--   </pre>
getCellRendererPixbufTexture :: (MonadIO m, IsCellRendererPixbuf o) => o -> m (Maybe Texture)

-- | Set the value of the “<tt>texture</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererPixbuf [ #texture <a>:=</a> value ]
--   </pre>
setCellRendererPixbufTexture :: (MonadIO m, IsCellRendererPixbuf o, IsTexture a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererPixbuf.CellRendererPixbuf
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererPixbuf.CellRendererPixbuf
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererPixbuf.CellRendererPixbuf
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererPixbuf.CellRendererPixbuf o) => GI.Gtk.Objects.CellRendererPixbuf.IsCellRendererPixbuf o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererPixbuf.CellRendererPixbuf)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererPixbuf.CellRendererPixbuf
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererPixbuf.CellRendererPixbuf


-- | Renders a combobox in a cell
--   
--   <tt>GtkCellRendererCombo</tt> renders text in a cell like
--   <tt>GtkCellRendererText</tt> from which it is derived. But while
--   <tt>GtkCellRendererText</tt> offers a simple entry to edit the text,
--   <tt>GtkCellRendererCombo</tt> offers a <tt>GtkComboBox</tt> widget to
--   edit the text. The values to display in the combo box are taken from
--   the tree model specified in the <tt>GtkCellRendererCombo</tt>:model
--   property.
--   
--   The combo cell renderer takes care of adding a text cell renderer to
--   the combo box and sets it to display the column specified by its
--   <tt>GtkCellRendererCombo</tt>:text-column property. Further properties
--   of the combo box can be set in a handler for the
--   <tt>GtkCellRenderer::editing-started</tt> signal.
module GI.Gtk.Objects.CellRendererCombo

-- | Memory-managed wrapper type.
newtype CellRendererCombo
CellRendererCombo :: ManagedPtr CellRendererCombo -> CellRendererCombo

-- | Type class for types which can be safely cast to
--   <a>CellRendererCombo</a>, for instance with
--   <a>toCellRendererCombo</a>.
class (GObject o, IsDescendantOf CellRendererCombo o) => IsCellRendererCombo o

-- | Cast to <a>CellRendererCombo</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererCombo :: (MonadIO m, IsCellRendererCombo o) => o -> m CellRendererCombo

-- | Creates a new <tt>GtkCellRendererCombo</tt>. Adjust how text is drawn
--   using object properties. Object properties can be set globally (with
--   <tt><i>g_object_set()</i></tt>). Also, with
--   <tt>GtkTreeViewColumn</tt>, you can bind a property to a value in a
--   <tt>GtkTreeModel</tt>. For example, you can bind the “text” property
--   on the cell renderer to a string value in the model, thus rendering a
--   different string in each row of the <tt>GtkTreeView</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererComboNew :: (HasCallStack, MonadIO m) => m CellRendererCombo

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-entry</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererComboHasEntry :: (IsCellRendererCombo o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererCombo #hasEntry
--   </pre>
getCellRendererComboHasEntry :: (MonadIO m, IsCellRendererCombo o) => o -> m Bool

-- | Set the value of the “<tt>has-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererCombo [ #hasEntry <a>:=</a> value ]
--   </pre>
setCellRendererComboHasEntry :: (MonadIO m, IsCellRendererCombo o) => o -> Bool -> m ()

-- | Set the value of the “<tt>model</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #model
--   </pre>
clearCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>model</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererComboModel :: (IsCellRendererCombo o, MonadIO m, IsTreeModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererCombo #model
--   </pre>
getCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o) => o -> m (Maybe TreeModel)

-- | Set the value of the “<tt>model</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererCombo [ #model <a>:=</a> value ]
--   </pre>
setCellRendererComboModel :: (MonadIO m, IsCellRendererCombo o, IsTreeModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text-column</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererComboTextColumn :: (IsCellRendererCombo o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererCombo #textColumn
--   </pre>
getCellRendererComboTextColumn :: (MonadIO m, IsCellRendererCombo o) => o -> m Int32

-- | Set the value of the “<tt>text-column</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererCombo [ #textColumn <a>:=</a> value ]
--   </pre>
setCellRendererComboTextColumn :: (MonadIO m, IsCellRendererCombo o) => o -> Int32 -> m ()

-- | This signal is emitted each time after the user selected an item in
--   the combo box, either by using the mouse or the arrow keys. Contrary
--   to GtkComboBox, GtkCellRendererCombo<a>changed</a> is not emitted for
--   changes made to a selected item in the entry. The argument
--   <i><tt>newIter</tt></i> corresponds to the newly selected item in the
--   combo box and it is relative to the GtkTreeModel set via the model
--   property on GtkCellRendererCombo.
--   
--   Note that as soon as you change the model displayed in the tree view,
--   the tree view will immediately cease the editing operating. This means
--   that you most probably want to refrain from changing the model until
--   the combo cell renderer emits the edited or editing_canceled signal.
type CellRendererComboChangedCallback = Text -> TreeIter -> IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererCombo #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererComboChanged :: (IsCellRendererCombo a, MonadIO m) => a -> ((?self :: a) => CellRendererComboChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererCombo #changed callback
--   </pre>
onCellRendererComboChanged :: (IsCellRendererCombo a, MonadIO m) => a -> ((?self :: a) => CellRendererComboChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererCombo.CellRendererCombo
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererCombo.CellRendererCombo
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererCombo.CellRendererCombo
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererCombo.CellRendererCombo o) => GI.Gtk.Objects.CellRendererCombo.IsCellRendererCombo o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererCombo.CellRendererCombo)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererCombo.CellRendererCombo
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererCombo.CellRendererCombo


-- | Renders a keyboard accelerator in a cell
--   
--   <tt>GtkCellRendererAccel</tt> displays a keyboard accelerator (i.e. a
--   key combination like <tt>Control + a</tt>). If the cell renderer is
--   editable, the accelerator can be changed by simply typing the new
--   combination.
module GI.Gtk.Objects.CellRendererAccel

-- | Memory-managed wrapper type.
newtype CellRendererAccel
CellRendererAccel :: ManagedPtr CellRendererAccel -> CellRendererAccel

-- | Type class for types which can be safely cast to
--   <a>CellRendererAccel</a>, for instance with
--   <a>toCellRendererAccel</a>.
class (GObject o, IsDescendantOf CellRendererAccel o) => IsCellRendererAccel o

-- | Cast to <a>CellRendererAccel</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellRendererAccel :: (MonadIO m, IsCellRendererAccel o) => o -> m CellRendererAccel

-- | Creates a new <tt>GtkCellRendererAccel</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererAccelNew :: (HasCallStack, MonadIO m) => m CellRendererAccel

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-key</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererAccelAccelKey :: (IsCellRendererAccel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>accel-key</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #accelKey
--   </pre>
getCellRendererAccelAccelKey :: (MonadIO m, IsCellRendererAccel o) => o -> m Word32

-- | Set the value of the “<tt>accel-key</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #accelKey <a>:=</a> value ]
--   </pre>
setCellRendererAccelAccelKey :: (MonadIO m, IsCellRendererAccel o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererAccelAccelMode :: (IsCellRendererAccel o, MonadIO m) => CellRendererAccelMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>accel-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #accelMode
--   </pre>
getCellRendererAccelAccelMode :: (MonadIO m, IsCellRendererAccel o) => o -> m CellRendererAccelMode

-- | Set the value of the “<tt>accel-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #accelMode <a>:=</a> value ]
--   </pre>
setCellRendererAccelAccelMode :: (MonadIO m, IsCellRendererAccel o) => o -> CellRendererAccelMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>accel-mods</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererAccelAccelMods :: (IsCellRendererAccel o, MonadIO m) => [ModifierType] -> m (GValueConstruct o)

-- | Get the value of the “<tt>accel-mods</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #accelMods
--   </pre>
getCellRendererAccelAccelMods :: (MonadIO m, IsCellRendererAccel o) => o -> m [ModifierType]

-- | Set the value of the “<tt>accel-mods</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #accelMods <a>:=</a> value ]
--   </pre>
setCellRendererAccelAccelMods :: (MonadIO m, IsCellRendererAccel o) => o -> [ModifierType] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>keycode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererAccelKeycode :: (IsCellRendererAccel o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>keycode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRendererAccel #keycode
--   </pre>
getCellRendererAccelKeycode :: (MonadIO m, IsCellRendererAccel o) => o -> m Word32

-- | Set the value of the “<tt>keycode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRendererAccel [ #keycode <a>:=</a> value ]
--   </pre>
setCellRendererAccelKeycode :: (MonadIO m, IsCellRendererAccel o) => o -> Word32 -> m ()

-- | Gets emitted when the user has removed the accelerator.
type CellRendererAccelAccelClearedCallback = Text -> IO ()

-- | Connect a signal handler for the <a>accelCleared</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererAccel #accelCleared callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererAccelAccelCleared :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelClearedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelCleared</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererAccel #accelCleared callback
--   </pre>
onCellRendererAccelAccelCleared :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelClearedCallback) -> m SignalHandlerId

-- | Gets emitted when the user has selected a new accelerator.
type CellRendererAccelAccelEditedCallback = Text -> Word32 -> [ModifierType] -> Word32 -> IO ()

-- | Connect a signal handler for the <a>accelEdited</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellRendererAccel #accelEdited callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererAccelAccelEdited :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelEditedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>accelEdited</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellRendererAccel #accelEdited callback
--   </pre>
onCellRendererAccelAccelEdited :: (IsCellRendererAccel a, MonadIO m) => a -> ((?self :: a) => CellRendererAccelAccelEditedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CellRendererAccel.CellRendererAccel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRendererAccel.CellRendererAccel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRendererAccel.CellRendererAccel
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRendererAccel.CellRendererAccel o) => GI.Gtk.Objects.CellRendererAccel.IsCellRendererAccel o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRendererAccel.CellRendererAccel)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRendererAccel.CellRendererAccel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRendererAccel.CellRendererAccel


-- | An object for rendering a single cell
--   
--   The <tt>GtkCellRenderer</tt> is a base class of a set of objects used
--   for rendering a cell to a <tt>cairo_t</tt>. These objects are used
--   primarily by the <tt>GtkTreeView</tt> widget, though they aren’t tied
--   to them in any specific way. It is worth noting that
--   <tt>GtkCellRenderer</tt> is not a <tt>GtkWidget</tt> and cannot be
--   treated as such.
--   
--   The primary use of a <tt>GtkCellRenderer</tt> is for drawing a certain
--   graphical elements on a <tt>cairo_t</tt>. Typically, one cell renderer
--   is used to draw many cells on the screen. To this extent, it isn’t
--   expected that a CellRenderer keep any permanent state around. Instead,
--   any state is set just prior to use using <tt>GObject</tt>s property
--   system. Then, the cell is measured using
--   <a>cellRendererGetPreferredSize</a>. Finally, the cell is rendered in
--   the correct location using <a>cellRendererSnapshot</a>.
--   
--   There are a number of rules that must be followed when writing a new
--   <tt>GtkCellRenderer</tt>. First and foremost, it’s important that a
--   certain set of properties will always yield a cell renderer of the
--   same size, barring a style change. The <tt>GtkCellRenderer</tt> also
--   has a number of generic properties that are expected to be honored by
--   all children.
--   
--   Beyond merely rendering a cell, cell renderers can optionally provide
--   active user interface elements. A cell renderer can be “activatable”
--   like <tt>GtkCellRenderer</tt>Toggle, which toggles when it gets
--   activated by a mouse click, or it can be “editable” like
--   <tt>GtkCellRenderer</tt>Text, which allows the user to edit the text
--   using a widget implementing the <tt>GtkCellEditable</tt> interface,
--   e.g. <tt>GtkEntry</tt>. To make a cell renderer activatable or
--   editable, you have to implement the
--   <tt>GtkCellRenderer</tt>Class.activate or
--   <tt>GtkCellRenderer</tt>Class.start_editing virtual functions,
--   respectively.
--   
--   Many properties of <tt>GtkCellRenderer</tt> and its subclasses have a
--   corresponding “set” property, e.g. “cell-background-set” corresponds
--   to “cell-background”. These “set” properties reflect whether a
--   property has been set or not. You should not set them independently.
module GI.Gtk.Objects.CellRenderer

-- | Memory-managed wrapper type.
newtype CellRenderer
CellRenderer :: ManagedPtr CellRenderer -> CellRenderer

-- | Type class for types which can be safely cast to <a>CellRenderer</a>,
--   for instance with <a>toCellRenderer</a>.
class (GObject o, IsDescendantOf CellRenderer o) => IsCellRenderer o

-- | Cast to <a>CellRenderer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellRenderer :: (MonadIO m, IsCellRenderer o) => o -> m CellRenderer

-- | Passes an activate event to the cell renderer for possible processing.
--   Some cell renderers may use events; for example,
--   <tt>GtkCellRendererToggle</tt> toggles when it gets a mouse click.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererActivate :: (HasCallStack, MonadIO m, IsCellRenderer a, IsEvent b, IsWidget c) => a -> b -> c -> Text -> Rectangle -> Rectangle -> [CellRendererState] -> m Bool

-- | Gets the aligned area used by <i><tt>cell</tt></i> inside
--   <i><tt>cellArea</tt></i>. Used for finding the appropriate edit and
--   focus rectangle.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetAlignedArea :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> [CellRendererState] -> Rectangle -> m Rectangle

-- | Fills in <i><tt>xalign</tt></i> and <i><tt>yalign</tt></i> with the
--   appropriate values of <i><tt>cell</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetAlignment :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Float, Float)

-- | Fills in <i><tt>width</tt></i> and <i><tt>height</tt></i> with the
--   appropriate size of <i><tt>cell</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetFixedSize :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

-- | Checks whether the given <tt>GtkCellRenderer</tt> is expanded.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetIsExpanded :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Checks whether the given <tt>GtkCellRenderer</tt> is an expander.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetIsExpander :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Fills in <i><tt>xpad</tt></i> and <i><tt>ypad</tt></i> with the
--   appropriate values of <i><tt>cell</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m (Int32, Int32)

-- | Retrieves a renderer’s natural size when rendered to
--   <i><tt>widget</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Int32, Int32)

-- | Retrieves a cell renderers’s minimum and natural height if it were
--   rendered to <i><tt>widget</tt></i> with the specified
--   <i><tt>width</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m (Int32, Int32)

-- | Retrieves the minimum and natural size of a cell taking into account
--   the widget’s preference for height-for-width management.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetPreferredSize :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Requisition, Requisition)

-- | Retrieves a renderer’s natural size when rendered to
--   <i><tt>widget</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> m (Int32, Int32)

-- | Retrieves a cell renderers’s minimum and natural width if it were
--   rendered to <i><tt>widget</tt></i> with the specified
--   <i><tt>height</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => a -> b -> Int32 -> m (Int32, Int32)

-- | Gets whether the cell renderer prefers a height-for-width layout or a
--   width-for-height layout.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetRequestMode :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m SizeRequestMode

-- | Returns the cell renderer’s sensitivity.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetSensitive :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Translates the cell renderer state to <tt>GtkStateFlags</tt>, based on
--   the cell renderer and widget sensitivity, and the given
--   <tt>GtkCellRenderer</tt>State.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetState :: (HasCallStack, MonadIO m, IsCellRenderer a, IsWidget b) => Maybe a -> Maybe b -> [CellRendererState] -> m [StateFlags]

-- | Returns the cell renderer’s visibility.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererGetVisible :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Checks whether the cell renderer can do something when activated.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererIsActivatable :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> m Bool

-- | Sets the renderer’s alignment within its available space.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSetAlignment :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Float -> Float -> m ()

-- | Sets the renderer size to be explicit, independent of the properties
--   set.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSetFixedSize :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Int32 -> Int32 -> m ()

-- | Sets whether the given <tt>GtkCellRenderer</tt> is expanded.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSetIsExpanded :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Sets whether the given <tt>GtkCellRenderer</tt> is an expander.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSetIsExpander :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Sets the renderer’s padding.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSetPadding :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Int32 -> Int32 -> m ()

-- | Sets the cell renderer’s sensitivity.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSetSensitive :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Sets the cell renderer’s visibility.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSetVisible :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Invokes the virtual render function of the <tt>GtkCellRenderer</tt>.
--   The three passed-in rectangles are areas in <i><tt>cr</tt></i>. Most
--   renderers will draw within <i><tt>cellArea</tt></i>; the xalign,
--   yalign, xpad, and ypad fields of the <tt>GtkCellRenderer</tt> should
--   be honored with respect to <i><tt>cellArea</tt></i>.
--   <i><tt>backgroundArea</tt></i> includes the blank space around the
--   cell, and also the area containing the tree expander; so the
--   <i><tt>backgroundArea</tt></i> rectangles for all cells tile to cover
--   the entire <i><tt>window</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererSnapshot :: (HasCallStack, MonadIO m, IsCellRenderer a, IsSnapshot b, IsWidget c) => a -> b -> c -> Rectangle -> Rectangle -> [CellRendererState] -> m ()

-- | Starts editing the contents of this <i><tt>cell</tt></i>, through a
--   new <tt>GtkCellEditable</tt> widget created by the
--   <tt>GtkCellRenderer</tt>Class.start_editing virtual function.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererStartEditing :: (HasCallStack, MonadIO m, IsCellRenderer a, IsEvent b, IsWidget c) => a -> Maybe b -> c -> Text -> Rectangle -> Rectangle -> [CellRendererState] -> m (Maybe CellEditable)

-- | Informs the cell renderer that the editing is stopped. If
--   <i><tt>canceled</tt></i> is <a>True</a>, the cell renderer will emit
--   the <tt>GtkCellRenderer</tt><a>editingCanceled</a> signal.
--   
--   This function should be called by cell renderer implementations in
--   response to the <tt>GtkCellEditable::editing-done</tt> signal of
--   <tt>GtkCellEditable</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellRendererStopEditing :: (HasCallStack, MonadIO m, IsCellRenderer a) => a -> Bool -> m ()

-- | Set the value of the “<tt>cell-background</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cellBackground
--   </pre>
clearCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-background</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellRendererCellBackground :: (IsCellRenderer o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Set the value of the “<tt>cell-background</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #cellBackground <a>:=</a> value ]
--   </pre>
setCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> Text -> m ()

-- | Set the value of the “<tt>cell-background-rgba</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cellBackgroundRgba
--   </pre>
clearCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-background-rgba</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererCellBackgroundRgba :: (IsCellRenderer o, MonadIO m) => RGBA -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #cellBackgroundRgba
--   </pre>
getCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe RGBA)

-- | Set the value of the “<tt>cell-background-rgba</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #cellBackgroundRgba <a>:=</a> value ]
--   </pre>
setCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> RGBA -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cell-background-set</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructCellRendererCellBackgroundSet :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>cell-background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #cellBackgroundSet
--   </pre>
getCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>cell-background-set</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #cellBackgroundSet <a>:=</a> value ]
--   </pre>
setCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Get the value of the “<tt>editing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #editing
--   </pre>
getCellRendererEditing :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>height</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererHeight :: (IsCellRenderer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #height
--   </pre>
getCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> m Int32

-- | Set the value of the “<tt>height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #height <a>:=</a> value ]
--   </pre>
setCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-expanded</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererIsExpanded :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #isExpanded
--   </pre>
getCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>is-expanded</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #isExpanded <a>:=</a> value ]
--   </pre>
setCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-expander</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCellRendererIsExpander :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-expander</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #isExpander
--   </pre>
getCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>is-expander</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #isExpander <a>:=</a> value ]
--   </pre>
setCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mode</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererMode :: (IsCellRenderer o, MonadIO m) => CellRendererMode -> m (GValueConstruct o)

-- | Get the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #mode
--   </pre>
getCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> m CellRendererMode

-- | Set the value of the “<tt>mode</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #mode <a>:=</a> value ]
--   </pre>
setCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> CellRendererMode -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sensitive</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellRendererSensitive :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #sensitive
--   </pre>
getCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>sensitive</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #sensitive <a>:=</a> value ]
--   </pre>
setCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>visible</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererVisible :: (IsCellRenderer o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #visible
--   </pre>
getCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> m Bool

-- | Set the value of the “<tt>visible</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #visible <a>:=</a> value ]
--   </pre>
setCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererWidth :: (IsCellRenderer o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #width
--   </pre>
getCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> m Int32

-- | Set the value of the “<tt>width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #width <a>:=</a> value ]
--   </pre>
setCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererXalign :: (IsCellRenderer o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #xalign
--   </pre>
getCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #xalign <a>:=</a> value ]
--   </pre>
setCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xpad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererXpad :: (IsCellRenderer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>xpad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #xpad
--   </pre>
getCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32

-- | Set the value of the “<tt>xpad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #xpad <a>:=</a> value ]
--   </pre>
setCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererYalign :: (IsCellRenderer o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #yalign
--   </pre>
getCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #yalign <a>:=</a> value ]
--   </pre>
setCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ypad</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellRendererYpad :: (IsCellRenderer o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>ypad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellRenderer #ypad
--   </pre>
getCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32

-- | Set the value of the “<tt>ypad</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellRenderer [ #ypad <a>:=</a> value ]
--   </pre>
setCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m ()

-- | This signal gets emitted when the user cancels the process of editing
--   a cell. For example, an editable cell renderer could be written to
--   cancel editing when the user presses Escape.
--   
--   See also: <a>cellRendererStopEditing</a>.
type CellRendererEditingCanceledCallback = IO ()

-- | Connect a signal handler for the <a>editingCanceled</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellRenderer #editingCanceled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>editingCanceled</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellRenderer #editingCanceled callback
--   </pre>
onCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingCanceledCallback) -> m SignalHandlerId

-- | This signal gets emitted when a cell starts to be edited. The intended
--   use of this signal is to do special setup on <i><tt>editable</tt></i>,
--   e.g. adding a <tt>GtkEntryCompletion</tt> or setting up additional
--   columns in a <tt>GtkComboBox</tt>.
--   
--   See <a>cellEditableStartEditing</a> for information on the lifecycle
--   of the <i><tt>editable</tt></i> and a way to do setup that doesn’t
--   depend on the <i><tt>renderer</tt></i>.
--   
--   Note that GTK doesn't guarantee that cell renderers will continue to
--   use the same kind of widget for editing in future releases, therefore
--   you should check the type of <i><tt>editable</tt></i> before doing any
--   specific setup, as in the following example:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   text_editing_started (GtkCellRenderer *cell,
--                         GtkCellEditable *editable,
--                         const char      *path,
--                         gpointer         data)
--   {
--     if (GTK_IS_ENTRY (editable))
--       {
--         GtkEntry *entry = GTK_ENTRY (editable);
--   
--         // ... create a GtkEntryCompletion
--   
--         gtk_entry_set_completion (entry, completion);
--       }
--   }
--   </pre>
type CellRendererEditingStartedCallback = CellEditable -> Text -> IO ()

-- | Connect a signal handler for the <a>editingStarted</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellRenderer #editingStarted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>editingStarted</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellRenderer #editingStarted callback
--   </pre>
onCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> ((?self :: a) => CellRendererEditingStartedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CellRenderer.CellRenderer
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellRenderer.CellRenderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellRenderer.CellRenderer
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellRenderer.CellRenderer o) => GI.Gtk.Objects.CellRenderer.IsCellRenderer o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellRenderer.CellRenderer)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellRenderer.CellRenderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellRenderer.CellRenderer


-- | Stores geometrical information for a series of rows in a GtkCellArea
--   
--   The <tt>GtkCellAreaContext</tt> object is created by a given
--   <tt>GtkCellArea</tt> implementation via its
--   <tt>GtkCellAreaClass.create_context()</tt> virtual method and is used
--   to store cell sizes and alignments for a series of
--   <tt>GtkTreeModel</tt> rows that are requested and rendered in the same
--   context.
--   
--   <tt>GtkCellLayout</tt> widgets can create any number of contexts in
--   which to request and render groups of data rows. However, it’s
--   important that the same context which was used to request sizes for a
--   given <tt>GtkTreeModel</tt> row also be used for the same row when
--   calling other <tt>GtkCellArea</tt> APIs such as
--   <tt><i>gtk_cell_area_render()</i></tt> and <a>cellAreaEvent</a>.
module GI.Gtk.Objects.CellAreaContext

-- | Memory-managed wrapper type.
newtype CellAreaContext
CellAreaContext :: ManagedPtr CellAreaContext -> CellAreaContext

-- | Type class for types which can be safely cast to
--   <a>CellAreaContext</a>, for instance with <a>toCellAreaContext</a>.
class (GObject o, IsDescendantOf CellAreaContext o) => IsCellAreaContext o

-- | Cast to <a>CellAreaContext</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCellAreaContext :: (MonadIO m, IsCellAreaContext o) => o -> m CellAreaContext

-- | Allocates a width and/or a height for all rows which are to be
--   rendered with <i><tt>context</tt></i>.
--   
--   Usually allocation is performed only horizontally or sometimes
--   vertically since a group of rows are usually rendered side by side
--   vertically or horizontally and share either the same width or the same
--   height. Sometimes they are allocated in both horizontal and vertical
--   orientations producing a homogeneous effect of the rows. This is
--   generally the case for <tt>GtkTreeView</tt> when
--   <tt>GtkTreeView:fixed-height-mode</tt> is enabled.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextAllocate :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Fetches the current allocation size for <i><tt>context</tt></i>.
--   
--   If the context was not allocated in width or height, or if the context
--   was recently reset with <a>cellAreaContextReset</a>, the returned
--   value will be -1.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextGetAllocation :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Fetches the <tt>GtkCellArea</tt> this <i><tt>context</tt></i> was
--   created by.
--   
--   This is generally unneeded by layouting widgets; however, it is
--   important for the context implementation itself to fetch information
--   about the area it is being used for.
--   
--   For instance at <tt>GtkCellAreaContextClass.allocate()</tt> time it’s
--   important to know details about any cell spacing that the
--   <tt>GtkCellArea</tt> is configured with in order to compute a proper
--   allocation.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextGetArea :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m CellArea

-- | Gets the accumulative preferred height for all rows which have been
--   requested with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <tt>GtkCellArea</tt>, the returned values are
--   0.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Gets the accumulative preferred height for <i><tt>width</tt></i> for
--   all rows which have been requested for the same said
--   <i><tt>width</tt></i> with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <tt>GtkCellArea</tt>, the returned values are
--   -1.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m (Int32, Int32)

-- | Gets the accumulative preferred width for all rows which have been
--   requested with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <tt>GtkCellArea</tt>, the returned values are
--   0.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m (Int32, Int32)

-- | Gets the accumulative preferred width for <i><tt>height</tt></i> for
--   all rows which have been requested for the same said
--   <i><tt>height</tt></i> with this context.
--   
--   After <a>cellAreaContextReset</a> is called and/or before ever
--   requesting the size of a <tt>GtkCellArea</tt>, the returned values are
--   -1.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> m (Int32, Int32)

-- | Causes the minimum and/or natural height to grow if the new proposed
--   sizes exceed the current minimum and natural height.
--   
--   This is used by <tt>GtkCellAreaContext</tt> implementations during the
--   request process over a series of <tt>GtkTreeModel</tt> rows to
--   progressively push the requested height over a series of
--   <a>cellAreaGetPreferredHeight</a> requests.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextPushPreferredHeight :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Causes the minimum and/or natural width to grow if the new proposed
--   sizes exceed the current minimum and natural width.
--   
--   This is used by <tt>GtkCellAreaContext</tt> implementations during the
--   request process over a series of <tt>GtkTreeModel</tt> rows to
--   progressively push the requested width over a series of
--   <a>cellAreaGetPreferredWidth</a> requests.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextPushPreferredWidth :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> Int32 -> Int32 -> m ()

-- | Resets any previously cached request and allocation data.
--   
--   When underlying <tt>GtkTreeModel</tt> data changes its important to
--   reset the context if the content size is allowed to shrink. If the
--   content size is only allowed to grow (this is usually an option for
--   views rendering large data stores as a measure of optimization), then
--   only the row that changed or was inserted needs to be (re)requested
--   with <a>cellAreaGetPreferredWidth</a>.
--   
--   When the new overall size of the context requires that the allocated
--   size changes (or whenever this allocation changes at all), the
--   variable row sizes need to be re-requested for every row.
--   
--   For instance, if the rows are displayed all with the same width from
--   top to bottom then a change in the allocated width necessitates a
--   recalculation of all the displayed row heights using
--   <a>cellAreaGetPreferredHeightForWidth</a>.

-- | <i>Deprecated: (Since version 4.10)This object will be removed in GTK
--   5</i>
cellAreaContextReset :: (HasCallStack, MonadIO m, IsCellAreaContext a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>area</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellAreaContextArea :: (IsCellAreaContext o, MonadIO m, IsCellArea a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>area</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #area
--   </pre>
getCellAreaContextArea :: (MonadIO m, IsCellAreaContext o) => o -> m CellArea

-- | Get the value of the “<tt>minimum-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #minimumHeight
--   </pre>
getCellAreaContextMinimumHeight :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “<tt>minimum-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #minimumWidth
--   </pre>
getCellAreaContextMinimumWidth :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “<tt>natural-height</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #naturalHeight
--   </pre>
getCellAreaContextNaturalHeight :: (MonadIO m, IsCellAreaContext o) => o -> m Int32

-- | Get the value of the “<tt>natural-width</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaContext #naturalWidth
--   </pre>
getCellAreaContextNaturalWidth :: (MonadIO m, IsCellAreaContext o) => o -> m Int32
instance GHC.Classes.Eq GI.Gtk.Objects.CellAreaContext.CellAreaContext
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellAreaContext.CellAreaContext
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellAreaContext.CellAreaContext
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellAreaContext.CellAreaContext o) => GI.Gtk.Objects.CellAreaContext.IsCellAreaContext o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellAreaContext.CellAreaContext)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellAreaContext.CellAreaContext
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellAreaContext.CellAreaContext


-- | A cell area that renders GtkCellRenderers into a row or a column
--   
--   The <tt>GtkCellAreaBox</tt> renders cell renderers into a row or a
--   column depending on its <tt>GtkOrientation</tt>.
--   
--   GtkCellAreaBox uses a notion of packing. Packing refers to adding cell
--   renderers with reference to a particular position in a
--   <tt>GtkCellAreaBox</tt>. There are two reference positions: the start
--   and the end of the box. When the <tt>GtkCellAreaBox</tt> is oriented
--   in the <a>OrientationVertical</a> orientation, the start is defined as
--   the top of the box and the end is defined as the bottom. In the
--   <a>OrientationHorizontal</a> orientation start is defined as the left
--   side and the end is defined as the right side.
--   
--   Alignments of <tt>GtkCellRenderer</tt>s rendered in adjacent rows can
--   be configured by configuring the <tt>GtkCellAreaBox</tt> align child
--   cell property with <a>cellAreaCellSetProperty</a> or by specifying the
--   "align" argument to <a>cellAreaBoxPackStart</a> and
--   <a>cellAreaBoxPackEnd</a>.
module GI.Gtk.Objects.CellAreaBox

-- | Memory-managed wrapper type.
newtype CellAreaBox
CellAreaBox :: ManagedPtr CellAreaBox -> CellAreaBox

-- | Type class for types which can be safely cast to <a>CellAreaBox</a>,
--   for instance with <a>toCellAreaBox</a>.
class (GObject o, IsDescendantOf CellAreaBox o) => IsCellAreaBox o

-- | Cast to <a>CellAreaBox</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellAreaBox :: (MonadIO m, IsCellAreaBox o) => o -> m CellAreaBox

-- | Gets the spacing added between cell renderers.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaBoxGetSpacing :: (HasCallStack, MonadIO m, IsCellAreaBox a) => a -> m Int32

-- | Creates a new <tt>GtkCellAreaBox</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaBoxNew :: (HasCallStack, MonadIO m) => m CellAreaBox

-- | Adds <i><tt>renderer</tt></i> to <i><tt>box</tt></i>, packed with
--   reference to the end of <i><tt>box</tt></i>.
--   
--   The <i><tt>renderer</tt></i> is packed after (away from end of) any
--   other <tt>GtkCellRenderer</tt> packed with reference to the end of
--   <i><tt>box</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaBoxPackEnd :: (HasCallStack, MonadIO m, IsCellAreaBox a, IsCellRenderer b) => a -> b -> Bool -> Bool -> Bool -> m ()

-- | Adds <i><tt>renderer</tt></i> to <i><tt>box</tt></i>, packed with
--   reference to the start of <i><tt>box</tt></i>.
--   
--   The <i><tt>renderer</tt></i> is packed after any other
--   <tt>GtkCellRenderer</tt> packed with reference to the start of
--   <i><tt>box</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaBoxPackStart :: (HasCallStack, MonadIO m, IsCellAreaBox a, IsCellRenderer b) => a -> b -> Bool -> Bool -> Bool -> m ()

-- | Sets the spacing to add between cell renderers in <i><tt>box</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaBoxSetSpacing :: (HasCallStack, MonadIO m, IsCellAreaBox a) => a -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCellAreaBoxSpacing :: (IsCellAreaBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellAreaBox #spacing
--   </pre>
getCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellAreaBox [ #spacing <a>:=</a> value ]
--   </pre>
setCellAreaBoxSpacing :: (MonadIO m, IsCellAreaBox o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.CellAreaBox.CellAreaBox
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellAreaBox.CellAreaBox
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellAreaBox.CellAreaBox
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellAreaBox.CellAreaBox o) => GI.Gtk.Objects.CellAreaBox.IsCellAreaBox o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellAreaBox.CellAreaBox)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellAreaBox.CellAreaBox
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellAreaBox.CellAreaBox


-- | An abstract class for laying out <tt>GtkCellRenderer</tt>s
--   
--   The <tt>GtkCellArea</tt> is an abstract class for <a>CellLayout</a>
--   widgets (also referred to as "layouting widgets") to interface with an
--   arbitrary number of <a>CellRenderer</a>s and interact with the user
--   for a given <a>TreeModel</a> row.
--   
--   The cell area handles events, focus navigation, drawing and size
--   requests and allocations for a given row of data.
--   
--   Usually users dont have to interact with the <tt>GtkCellArea</tt>
--   directly unless they are implementing a cell-layouting widget
--   themselves.
--   
--   <h2>Requesting area sizes</h2>
--   
--   As outlined in <a>GtkWidget’s geometry management section</a>, GTK
--   uses a height-for-width geometry management system to compute the
--   sizes of widgets and user interfaces. <tt>GtkCellArea</tt> uses the
--   same semantics to calculate the size of an area for an arbitrary
--   number of <tt>GtkTreeModel</tt> rows.
--   
--   When requesting the size of a cell area one needs to calculate the
--   size for a handful of rows, and this will be done differently by
--   different layouting widgets. For instance a <a>TreeViewColumn</a>
--   always lines up the areas from top to bottom while a <a>IconView</a>
--   on the other hand might enforce that all areas received the same width
--   and wrap the areas around, requesting height for more cell areas when
--   allocated less width.
--   
--   It’s also important for areas to maintain some cell alignments with
--   areas rendered for adjacent rows (cells can appear “columnized” inside
--   an area even when the size of cells are different in each row). For
--   this reason the <tt>GtkCellArea</tt> uses a <a>CellAreaContext</a>
--   object to store the alignments and sizes along the way (as well as the
--   overall largest minimum and natural size for all the rows which have
--   been calculated with the said context).
--   
--   The <a>CellAreaContext</a> is an opaque object specific to the
--   <tt>GtkCellArea</tt> which created it (see
--   <a>cellAreaCreateContext</a>).
--   
--   The owning cell-layouting widget can create as many contexts as it
--   wishes to calculate sizes of rows which should receive the same size
--   in at least one orientation (horizontally or vertically), However,
--   it’s important that the same <a>CellAreaContext</a> which was used to
--   request the sizes for a given <tt>GtkTreeModel</tt> row be used when
--   rendering or processing events for that row.
--   
--   In order to request the width of all the rows at the root level of a
--   <tt>GtkTreeModel</tt> one would do the following:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkTreeIter iter;
--   int minimum_width;
--   int natural_width;
--   
--   valid = gtk_tree_model_get_iter_first (model, &amp;iter);
--   while (valid)
--     {
--       gtk_cell_area_apply_attributes (area, model, &amp;iter, FALSE, FALSE);
--       gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
--   
--       valid = gtk_tree_model_iter_next (model, &amp;iter);
--     }
--   
--   gtk_cell_area_context_get_preferred_width (context, &amp;minimum_width, &amp;natural_width);
--   </pre>
--   
--   Note that in this example it’s not important to observe the returned
--   minimum and natural width of the area for each row unless the
--   cell-layouting object is actually interested in the widths of
--   individual rows. The overall width is however stored in the
--   accompanying <tt>GtkCellAreaContext</tt> object and can be consulted
--   at any time.
--   
--   This can be useful since <tt>GtkCellLayout</tt> widgets usually have
--   to support requesting and rendering rows in treemodels with an
--   exceedingly large amount of rows. The <tt>GtkCellLayout</tt> widget in
--   that case would calculate the required width of the rows in an idle or
--   timeout source (see <a>timeoutAdd</a>) and when the widget is
--   requested its actual width in <a>Widget</a>.<tt><i>measure</i></tt>()
--   it can simply consult the width accumulated so far in the
--   <tt>GtkCellAreaContext</tt> object.
--   
--   A simple example where rows are rendered from top to bottom and take
--   up the full width of the layouting widget would look like:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   foo_get_preferred_width (GtkWidget *widget,
--                            int       *minimum_size,
--                            int       *natural_size)
--   {
--     Foo *self = FOO (widget);
--     FooPrivate *priv = foo_get_instance_private (self);
--   
--     foo_ensure_at_least_one_handfull_of_rows_have_been_requested (self);
--   
--     gtk_cell_area_context_get_preferred_width (priv-&gt;context, minimum_size, natural_size);
--   }
--   </pre>
--   
--   In the above example the <tt>Foo</tt> widget has to make sure that
--   some row sizes have been calculated (the amount of rows that
--   <tt>Foo</tt> judged was appropriate to request space for in a single
--   timeout iteration) before simply returning the amount of space
--   required by the area via the <tt>GtkCellAreaContext</tt>.
--   
--   Requesting the height for width (or width for height) of an area is a
--   similar task except in this case the <tt>GtkCellAreaContext</tt> does
--   not store the data (actually, it does not know how much space the
--   layouting widget plans to allocate it for every row. It’s up to the
--   layouting widget to render each row of data with the appropriate
--   height and width which was requested by the <tt>GtkCellArea</tt>).
--   
--   In order to request the height for width of all the rows at the root
--   level of a <tt>GtkTreeModel</tt> one would do the following:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkTreeIter iter;
--   int minimum_height;
--   int natural_height;
--   int full_minimum_height = 0;
--   int full_natural_height = 0;
--   
--   valid = gtk_tree_model_get_iter_first (model, &amp;iter);
--   while (valid)
--     {
--       gtk_cell_area_apply_attributes (area, model, &amp;iter, FALSE, FALSE);
--       gtk_cell_area_get_preferred_height_for_width (area, context, widget,
--                                                     width, &amp;minimum_height, &amp;natural_height);
--   
--       if (width_is_for_allocation)
--          cache_row_height (&amp;iter, minimum_height, natural_height);
--   
--       full_minimum_height += minimum_height;
--       full_natural_height += natural_height;
--   
--       valid = gtk_tree_model_iter_next (model, &amp;iter);
--     }
--   </pre>
--   
--   Note that in the above example we would need to cache the heights
--   returned for each row so that we would know what sizes to render the
--   areas for each row. However we would only want to really cache the
--   heights if the request is intended for the layouting widgets real
--   allocation.
--   
--   In some cases the layouting widget is requested the height for an
--   arbitrary for_width, this is a special case for layouting widgets who
--   need to request size for tens of thousands of rows. For this case it’s
--   only important that the layouting widget calculate one reasonably
--   sized chunk of rows and return that height synchronously. The
--   reasoning here is that any layouting widget is at least capable of
--   synchronously calculating enough height to fill the screen height (or
--   scrolled window height) in response to a single call to
--   <a>Widget</a>.<tt><i>measure</i></tt>(). Returning a perfect height
--   for width that is larger than the screen area is inconsequential since
--   after the layouting receives an allocation from a scrolled window it
--   simply continues to drive the scrollbar values while more and more
--   height is required for the row heights that are calculated in the
--   background.
--   
--   <h2>Rendering Areas</h2>
--   
--   Once area sizes have been acquired at least for the rows in the
--   visible area of the layouting widget they can be rendered at
--   <a>Widget</a>.<tt><i>snapshot</i></tt>() time.
--   
--   A crude example of how to render all the rows at the root level runs
--   as follows:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkAllocation allocation;
--   GdkRectangle cell_area = { 0, };
--   GtkTreeIter iter;
--   int minimum_width;
--   int natural_width;
--   
--   gtk_widget_get_allocation (widget, &amp;allocation);
--   cell_area.width = allocation.width;
--   
--   valid = gtk_tree_model_get_iter_first (model, &amp;iter);
--   while (valid)
--     {
--       cell_area.height = get_cached_height_for_row (&amp;iter);
--   
--       gtk_cell_area_apply_attributes (area, model, &amp;iter, FALSE, FALSE);
--       gtk_cell_area_render (area, context, widget, cr,
--                             &amp;cell_area, &amp;cell_area, state_flags, FALSE);
--   
--       cell_area.y += cell_area.height;
--   
--       valid = gtk_tree_model_iter_next (model, &amp;iter);
--     }
--   </pre>
--   
--   Note that the cached height in this example really depends on how the
--   layouting widget works. The layouting widget might decide to give
--   every row its minimum or natural height or, if the model content is
--   expected to fit inside the layouting widget without scrolling, it
--   would make sense to calculate the allocation for each row at the time
--   the widget is allocated using <a>distributeNaturalAllocation</a>.
--   
--   <h2>Handling Events and Driving Keyboard Focus</h2>
--   
--   Passing events to the area is as simple as handling events on any
--   normal widget and then passing them to the <a>cellAreaEvent</a> API as
--   they come in. Usually <tt>GtkCellArea</tt> is only interested in
--   button events, however some customized derived areas can be
--   implemented who are interested in handling other events. Handling an
--   event can trigger the <a>CellArea::focusChanged</a> signal to fire; as
--   well as <a>CellArea::addEditable</a> in the case that an editable cell
--   was clicked and needs to start editing. You can call
--   <a>cellAreaStopEditing</a> at any time to cancel any cell editing that
--   is currently in progress.
--   
--   The <tt>GtkCellArea</tt> drives keyboard focus from cell to cell in a
--   way similar to <tt>GtkWidget</tt>. For layouting widgets that support
--   giving focus to cells it’s important to remember to pass
--   <tt>GTK_CELL_RENDERER_FOCUSED</tt> to the area functions for the row
--   that has focus and to tell the area to paint the focus at render time.
--   
--   Layouting widgets that accept focus on cells should implement the
--   <a>Widget</a>.<tt><i>focus</i></tt>() virtual method. The layouting
--   widget is always responsible for knowing where <tt>GtkTreeModel</tt>
--   rows are rendered inside the widget, so at
--   <a>Widget</a>.<tt><i>focus</i></tt>() time the layouting widget should
--   use the <tt>GtkCellArea</tt> methods to navigate focus inside the area
--   and then observe the <a>DirectionType</a> to pass the focus to
--   adjacent rows and areas.
--   
--   A basic example of how the <a>Widget</a>.<tt><i>focus</i></tt>()
--   virtual method should be implemented:
--   
--   <pre>
--   static gboolean
--   foo_focus (GtkWidget       *widget,
--              GtkDirectionType direction)
--   {
--     Foo *self = FOO (widget);
--     FooPrivate *priv = foo_get_instance_private (self);
--     int focus_row = priv-&gt;focus_row;
--     gboolean have_focus = FALSE;
--   
--     if (!gtk_widget_has_focus (widget))
--       gtk_widget_grab_focus (widget);
--   
--     valid = gtk_tree_model_iter_nth_child (priv-&gt;model, &amp;iter, NULL, priv-&gt;focus_row);
--     while (valid)
--       {
--         gtk_cell_area_apply_attributes (priv-&gt;area, priv-&gt;model, &amp;iter, FALSE, FALSE);
--   
--         if (gtk_cell_area_focus (priv-&gt;area, direction))
--           {
--              priv-&gt;focus_row = focus_row;
--              have_focus = TRUE;
--              break;
--           }
--         else
--           {
--             if (direction == GTK_DIR_RIGHT ||
--                 direction == GTK_DIR_LEFT)
--               break;
--             else if (direction == GTK_DIR_UP ||
--                      direction == GTK_DIR_TAB_BACKWARD)
--              {
--                 if (focus_row == 0)
--                   break;
--                 else
--                  {
--                     focus_row--;
--                     valid = gtk_tree_model_iter_nth_child (priv-&gt;model, &amp;iter, NULL, focus_row);
--                  }
--               }
--             else
--               {
--                 if (focus_row == last_row)
--                   break;
--                 else
--                   {
--                     focus_row++;
--                     valid = gtk_tree_model_iter_next (priv-&gt;model, &amp;iter);
--                   }
--               }
--           }
--       }
--       return have_focus;
--   }
--   </pre>
--   
--   Note that the layouting widget is responsible for matching the
--   <tt>GtkDirectionType</tt> values to the way it lays out its cells.
--   
--   <h2>Cell Properties</h2>
--   
--   The <tt>GtkCellArea</tt> introduces cell properties for
--   <tt>GtkCellRenderer</tt>s. This provides some general interfaces for
--   defining the relationship cell areas have with their cells. For
--   instance in a <a>CellAreaBox</a> a cell might “expand” and receive
--   extra space when the area is allocated more than its full natural
--   request, or a cell might be configured to “align” with adjacent rows
--   which were requested and rendered with the same
--   <tt>GtkCellAreaContext</tt>.
--   
--   Use <a>cellAreaClassInstallCellProperty</a> to install cell properties
--   for a cell area class and <a>cellAreaClassFindCellProperty</a> or
--   <a>cellAreaClassListCellProperties</a> to get information about
--   existing cell properties.
--   
--   To set the value of a cell property, use
--   <a>cellAreaCellSetProperty</a>,
--   <a>CellArea</a>.<tt><i>cell_set</i></tt>() or
--   <a>CellArea</a>.<tt><i>cell_set_valist</i></tt>(). To obtain the value
--   of a cell property, use <a>cellAreaCellGetProperty</a>
--   <a>CellArea</a>.<tt><i>cell_get</i></tt>() or
--   <a>CellArea</a>.<tt><i>cell_get_valist</i></tt>().
module GI.Gtk.Objects.CellArea

-- | Memory-managed wrapper type.
newtype CellArea
CellArea :: ManagedPtr CellArea -> CellArea

-- | Type class for types which can be safely cast to <a>CellArea</a>, for
--   instance with <a>toCellArea</a>.
class (GObject o, IsDescendantOf CellArea o) => IsCellArea o

-- | Cast to <a>CellArea</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCellArea :: (MonadIO m, IsCellArea o) => o -> m CellArea

-- | Activates <i><tt>area</tt></i>, usually by activating the currently
--   focused cell, however some subclasses which embed widgets in the area
--   can also activate a widget if it currently has the focus.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaActivate :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> [CellRendererState] -> Bool -> m Bool

-- | This is used by <tt>GtkCellArea</tt> subclasses when handling events
--   to activate cells, the base <tt>GtkCellArea</tt> class activates cells
--   for keyboard events for free in its own
--   GtkCellArea-&gt;<tt><i>activate()</i></tt> implementation.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaActivateCell :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b, IsCellRenderer c, IsEvent d) => a -> b -> c -> d -> Rectangle -> [CellRendererState] -> m Bool

-- | Adds <i><tt>renderer</tt></i> to <i><tt>area</tt></i> with the default
--   child cell properties.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaAdd :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Adds <i><tt>sibling</tt></i> to <i><tt>renderer</tt></i>’s focusable
--   area, focus will be drawn around <i><tt>renderer</tt></i> and all of
--   its siblings if <i><tt>renderer</tt></i> can focus for a given row.
--   
--   Events handled by focus siblings can also activate the given focusable
--   <i><tt>renderer</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaAddFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m ()

-- | Applies any connected attributes to the renderers in
--   <i><tt>area</tt></i> by pulling the values from
--   <i><tt>treeModel</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaApplyAttributes :: (HasCallStack, MonadIO m, IsCellArea a, IsTreeModel b) => a -> b -> TreeIter -> Bool -> Bool -> m ()

-- | Connects an <i><tt>attribute</tt></i> to apply values from
--   <i><tt>column</tt></i> for the <tt>GtkTreeModel</tt> in use.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaAttributeConnect :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Disconnects <i><tt>attribute</tt></i> for the <i><tt>renderer</tt></i>
--   in <i><tt>area</tt></i> so that attribute will no longer be updated
--   with values from the model.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaAttributeDisconnect :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> m ()

-- | Returns the model column that an attribute has been mapped to, or -1
--   if the attribute is not mapped.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaAttributeGetColumn :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> m Int32

-- | Gets the value of a cell property for <i><tt>renderer</tt></i> in
--   <i><tt>area</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaCellGetProperty :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> GValue -> m ()

-- | Sets a cell property for <i><tt>renderer</tt></i> in
--   <i><tt>area</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaCellSetProperty :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> Text -> GValue -> m ()

-- | This is sometimes needed for cases where rows need to share alignments
--   in one orientation but may be separately grouped in the opposing
--   orientation.
--   
--   For instance, <tt>GtkIconView</tt> creates all icons (rows) to have
--   the same width and the cells theirin to have the same horizontal
--   alignments. However each row of icons may have a separate collective
--   height. <tt>GtkIconView</tt> uses this to request the heights of each
--   row based on a context which was already used to request all the row
--   widths that are to be displayed.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaCopyContext :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b) => a -> b -> m CellAreaContext

-- | Creates a <tt>GtkCellArea</tt>Context to be used with
--   <i><tt>area</tt></i> for all purposes. <tt>GtkCellArea</tt>Context
--   stores geometry information for rows for which it was operated on, it
--   is important to use the same context for the same row of data at all
--   times (i.e. one should render and handle events with the same
--   <tt>GtkCellArea</tt>Context which was used to request the size of
--   those rows of data).

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaCreateContext :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m CellAreaContext

-- | Delegates event handling to a <tt>GtkCellArea</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaEvent :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c, IsEvent d) => a -> b -> c -> d -> Rectangle -> [CellRendererState] -> m Int32

-- | This should be called by the <i><tt>area</tt></i>’s owning layout
--   widget when focus is to be passed to <i><tt>area</tt></i>, or moved
--   within <i><tt>area</tt></i> for a given <i><tt>direction</tt></i> and
--   row data.
--   
--   Implementing <tt>GtkCellArea</tt> classes should implement this method
--   to receive and navigate focus in its own way particular to how it lays
--   out cells.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaFocus :: (HasCallStack, MonadIO m, IsCellArea a) => a -> DirectionType -> m Bool

-- | Calls <i><tt>callback</tt></i> for every <tt>GtkCellRenderer</tt> in
--   <i><tt>area</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaForeach :: (HasCallStack, MonadIO m, IsCellArea a) => a -> CellCallback -> m ()

-- | Calls <i><tt>callback</tt></i> for every <tt>GtkCellRenderer</tt> in
--   <i><tt>area</tt></i> with the allocated rectangle inside
--   <i><tt>cellArea</tt></i>.
cellAreaForeachAlloc :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Rectangle -> CellAllocCallback -> m ()

-- | Derives the allocation of <i><tt>renderer</tt></i> inside
--   <i><tt>area</tt></i> if <i><tt>area</tt></i> were to be rendered in
--   <i><tt>cellArea</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetCellAllocation :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c, IsCellRenderer d) => a -> b -> c -> d -> Rectangle -> m Rectangle

-- | Gets the <tt>GtkCellRenderer</tt> at <i><tt>x</tt></i> and
--   <i><tt>y</tt></i> coordinates inside <i><tt>area</tt></i> and
--   optionally returns the full cell allocation for it inside
--   <i><tt>cellArea</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetCellAtPosition :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Rectangle -> Int32 -> Int32 -> m (CellRenderer, Rectangle)

-- | Gets the current <tt>GtkTreePath</tt> string for the currently applied
--   <tt>GtkTreeIter</tt>, this is implicitly updated when
--   <a>cellAreaApplyAttributes</a> is called and can be used to interact
--   with renderers from <tt>GtkCellArea</tt> subclasses.
cellAreaGetCurrentPathString :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m Text

-- | Gets the <tt>GtkCellEditable</tt> widget currently used to edit the
--   currently edited cell.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetEditWidget :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m (Maybe CellEditable)

-- | Gets the <tt>GtkCellRenderer</tt> in <i><tt>area</tt></i> that is
--   currently being edited.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetEditedCell :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m (Maybe CellRenderer)

-- | Retrieves the currently focused cell for <i><tt>area</tt></i>

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetFocusCell :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m (Maybe CellRenderer)

-- | Gets the <tt>GtkCellRenderer</tt> which is expected to be focusable
--   for which <i><tt>renderer</tt></i> is, or may be a sibling.
--   
--   This is handy for <tt>GtkCellArea</tt> subclasses when handling
--   events, after determining the renderer at the event location it can
--   then chose to activate the focus cell for which the event cell may
--   have been a sibling.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetFocusFromSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m (Maybe CellRenderer)

-- | Gets the focus sibling cell renderers for <i><tt>renderer</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetFocusSiblings :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m [CellRenderer]

-- | Retrieves a cell area’s initial minimum and natural height.
--   
--   <i><tt>area</tt></i> will store some geometrical information in
--   <i><tt>context</tt></i> along the way; when requesting sizes over an
--   arbitrary number of rows, it’s not important to check the
--   <i><tt>minimumHeight</tt></i> and <i><tt>naturalHeight</tt></i> of
--   this call but rather to consult
--   <a>cellAreaContextGetPreferredHeight</a> after a series of requests.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetPreferredHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m (Int32, Int32)

-- | Retrieves a cell area’s minimum and natural height if it would be
--   given the specified <i><tt>width</tt></i>.
--   
--   <i><tt>area</tt></i> stores some geometrical information in
--   <i><tt>context</tt></i> along the way while calling
--   <a>cellAreaGetPreferredWidth</a>. It’s important to perform a series
--   of <a>cellAreaGetPreferredWidth</a> requests with
--   <i><tt>context</tt></i> first and then call
--   <a>cellAreaGetPreferredHeightForWidth</a> on each cell area
--   individually to get the height for width of each fully requested row.
--   
--   If at some point, the width of a single row changes, it should be
--   requested with <a>cellAreaGetPreferredWidth</a> again and then the
--   full width of the requested rows checked again with
--   <a>cellAreaContextGetPreferredWidth</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetPreferredHeightForWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

-- | Retrieves a cell area’s initial minimum and natural width.
--   
--   <i><tt>area</tt></i> will store some geometrical information in
--   <i><tt>context</tt></i> along the way; when requesting sizes over an
--   arbitrary number of rows, it’s not important to check the
--   <i><tt>minimumWidth</tt></i> and <i><tt>naturalWidth</tt></i> of this
--   call but rather to consult <a>cellAreaContextGetPreferredWidth</a>
--   after a series of requests.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetPreferredWidth :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> m (Int32, Int32)

-- | Retrieves a cell area’s minimum and natural width if it would be given
--   the specified <i><tt>height</tt></i>.
--   
--   <i><tt>area</tt></i> stores some geometrical information in
--   <i><tt>context</tt></i> along the way while calling
--   <a>cellAreaGetPreferredHeight</a>. It’s important to perform a series
--   of <a>cellAreaGetPreferredHeight</a> requests with
--   <i><tt>context</tt></i> first and then call
--   <a>cellAreaGetPreferredWidthForHeight</a> on each cell area
--   individually to get the height for width of each fully requested row.
--   
--   If at some point, the height of a single row changes, it should be
--   requested with <a>cellAreaGetPreferredHeight</a> again and then the
--   full height of the requested rows checked again with
--   <a>cellAreaContextGetPreferredHeight</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaGetPreferredWidthForHeight :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c) => a -> b -> c -> Int32 -> m (Int32, Int32)

-- | Gets whether the area prefers a height-for-width layout or a
--   width-for-height layout.
cellAreaGetRequestMode :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m SizeRequestMode

-- | Checks if <i><tt>area</tt></i> contains <i><tt>renderer</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaHasRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m Bool

-- | This is a convenience function for <tt>GtkCellArea</tt>
--   implementations to get the inner area where a given
--   <tt>GtkCellRenderer</tt> will be rendered. It removes any padding
--   previously added by <a>cellAreaRequestRenderer</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaInnerCellArea :: (HasCallStack, MonadIO m, IsCellArea a, IsWidget b) => a -> b -> Rectangle -> m Rectangle

-- | Returns whether the area can do anything when activated, after
--   applying new attributes to <i><tt>area</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaIsActivatable :: (HasCallStack, MonadIO m, IsCellArea a) => a -> m Bool

-- | Returns whether <i><tt>sibling</tt></i> is one of
--   <i><tt>renderer</tt></i>’s focus siblings (see
--   <a>cellAreaAddFocusSibling</a>).

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaIsFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m Bool

-- | Removes <i><tt>renderer</tt></i> from <i><tt>area</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaRemove :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> b -> m ()

-- | Removes <i><tt>sibling</tt></i> from <i><tt>renderer</tt></i>’s focus
--   sibling list (see <a>cellAreaAddFocusSibling</a>).

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaRemoveFocusSibling :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsCellRenderer c) => a -> b -> c -> m ()

-- | This is a convenience function for <tt>GtkCellArea</tt>
--   implementations to request size for cell renderers. It’s important to
--   use this function to request size and then use
--   <a>cellAreaInnerCellArea</a> at render and event time since this
--   function will add padding around the cell for focus painting.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaRequestRenderer :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b, IsWidget c) => a -> b -> Orientation -> c -> Int32 -> m (Int32, Int32)

-- | Explicitly sets the currently focused cell to
--   <i><tt>renderer</tt></i>.
--   
--   This is generally called by implementations of
--   <tt>GtkCellAreaClass.focus()</tt> or
--   <tt>GtkCellAreaClass.event()</tt>, however it can also be used to
--   implement functions such as <a>treeViewSetCursorOnCell</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaSetFocusCell :: (HasCallStack, MonadIO m, IsCellArea a, IsCellRenderer b) => a -> Maybe b -> m ()

-- | Snapshots <i><tt>area</tt></i>’s cells according to
--   <i><tt>area</tt></i>’s layout onto at the given coordinates.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaSnapshot :: (HasCallStack, MonadIO m, IsCellArea a, IsCellAreaContext b, IsWidget c, IsSnapshot d) => a -> b -> c -> d -> Rectangle -> Rectangle -> [CellRendererState] -> Bool -> m ()

-- | Explicitly stops the editing of the currently edited cell.
--   
--   If <i><tt>canceled</tt></i> is <a>True</a>, the currently edited cell
--   renderer will emit the <a>editingCanceled</a> signal, otherwise the
--   the <a>editingDone</a> signal will be emitted on the current edit
--   widget.
--   
--   See <a>cellAreaGetEditedCell</a> and <a>cellAreaGetEditWidget</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellAreaStopEditing :: (HasCallStack, MonadIO m, IsCellArea a) => a -> Bool -> m ()

-- | Get the value of the “<tt>edit-widget</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellArea #editWidget
--   </pre>
getCellAreaEditWidget :: (MonadIO m, IsCellArea o) => o -> m (Maybe CellEditable)

-- | Get the value of the “<tt>edited-cell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellArea #editedCell
--   </pre>
getCellAreaEditedCell :: (MonadIO m, IsCellArea o) => o -> m (Maybe CellRenderer)

-- | Set the value of the “<tt>focus-cell</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #focusCell
--   </pre>
clearCellAreaFocusCell :: (MonadIO m, IsCellArea o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>focus-cell</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCellAreaFocusCell :: (IsCellArea o, MonadIO m, IsCellRenderer a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>focus-cell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellArea #focusCell
--   </pre>
getCellAreaFocusCell :: (MonadIO m, IsCellArea o) => o -> m (Maybe CellRenderer)

-- | Set the value of the “<tt>focus-cell</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellArea [ #focusCell <a>:=</a> value ]
--   </pre>
setCellAreaFocusCell :: (MonadIO m, IsCellArea o, IsCellRenderer a) => o -> a -> m ()

-- | Indicates that editing has started on <i><tt>renderer</tt></i> and
--   that <i><tt>editable</tt></i> should be added to the owning
--   cell-layouting widget at <i><tt>cellArea</tt></i>.
type CellAreaAddEditableCallback = CellRenderer -> CellEditable -> Rectangle -> Text -> IO ()

-- | Connect a signal handler for the <a>addEditable</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #addEditable callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaAddEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaAddEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>addEditable</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #addEditable callback
--   </pre>
onCellAreaAddEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaAddEditableCallback) -> m SignalHandlerId

-- | This signal is emitted whenever applying attributes to
--   <i><tt>area</tt></i> from <i><tt>model</tt></i>
type CellAreaApplyAttributesCallback = TreeModel -> TreeIter -> Bool -> Bool -> IO ()

-- | Connect a signal handler for the <a>applyAttributes</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #applyAttributes callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaApplyAttributes :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaApplyAttributesCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applyAttributes</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #applyAttributes callback
--   </pre>
onCellAreaApplyAttributes :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaApplyAttributesCallback) -> m SignalHandlerId

-- | Indicates that focus changed on this <i><tt>area</tt></i>. This signal
--   is emitted either as a result of focus handling or event handling.
--   
--   It's possible that the signal is emitted even if the currently focused
--   renderer did not change, this is because focus may change to the same
--   renderer in the same cell area for a different row of data.
type CellAreaFocusChangedCallback = CellRenderer -> Text -> IO ()

-- | Connect a signal handler for the <a>focusChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #focusChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaFocusChanged :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaFocusChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>focusChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #focusChanged callback
--   </pre>
onCellAreaFocusChanged :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaFocusChangedCallback) -> m SignalHandlerId

-- | Indicates that editing finished on <i><tt>renderer</tt></i> and that
--   <i><tt>editable</tt></i> should be removed from the owning
--   cell-layouting widget.
type CellAreaRemoveEditableCallback = CellRenderer -> CellEditable -> IO ()

-- | Connect a signal handler for the <a>removeEditable</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> cellArea #removeEditable callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellAreaRemoveEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaRemoveEditableCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeEditable</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> cellArea #removeEditable callback
--   </pre>
onCellAreaRemoveEditable :: (IsCellArea a, MonadIO m) => a -> ((?self :: a) => CellAreaRemoveEditableCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.CellArea.CellArea
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CellArea.CellArea
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CellArea.CellArea
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CellArea.CellArea o) => GI.Gtk.Objects.CellArea.IsCellArea o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CellArea.CellArea)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CellArea.CellArea
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CellArea.CellArea


-- | Invokes a callback.
module GI.Gtk.Objects.CallbackAction

-- | Memory-managed wrapper type.
newtype CallbackAction
CallbackAction :: ManagedPtr CallbackAction -> CallbackAction

-- | Type class for types which can be safely cast to
--   <a>CallbackAction</a>, for instance with <a>toCallbackAction</a>.
class (GObject o, IsDescendantOf CallbackAction o) => IsCallbackAction o

-- | Cast to <a>CallbackAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCallbackAction :: (MonadIO m, IsCallbackAction o) => o -> m CallbackAction

-- | Create a custom action that calls the given <i><tt>callback</tt></i>
--   when activated.
callbackActionNew :: (HasCallStack, MonadIO m) => ShortcutFunc -> m CallbackAction
instance GHC.Classes.Eq GI.Gtk.Objects.CallbackAction.CallbackAction
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.CallbackAction.CallbackAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CallbackAction.CallbackAction
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CallbackAction.CallbackAction o) => GI.Gtk.Objects.CallbackAction.IsCallbackAction o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.CallbackAction.CallbackAction)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CallbackAction.CallbackAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CallbackAction.CallbackAction


-- | Displays a Gregorian calendar, one month at a time.
--   
--   &lt;picture&gt; &lt;source srcset="calendar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkCalendar" src="calendar.png"&gt; &lt;/picture&gt;
--   
--   A <tt>GtkCalendar</tt> can be created with <a>calendarNew</a>.
--   
--   The selected date can be retrieved from a <tt>GtkCalendar</tt> using
--   <a>calendarGetDate</a>. It can be altered with <a>calendarSetDate</a>.
--   
--   To place a visual marker on a particular day, use
--   <a>calendarMarkDay</a> and to remove the marker,
--   <a>calendarUnmarkDay</a>. Alternative, all marks can be cleared with
--   <a>calendarClearMarks</a>.
--   
--   Users should be aware that, although the Gregorian calendar is the
--   legal calendar in most countries, it was adopted progressively between
--   1582 and 1929. Display before these dates is likely to be historically
--   incorrect.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   <tt>GtkCalendar</tt> supports the following gestures:
--   
--   <ul>
--   <li>Scrolling up or down will switch to the previous or next
--   month.</li>
--   <li>Date strings can be dropped for setting the current day.</li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   calendar.view
--   ├── header
--   │   ├── button
--   │   ├── stack.month
--   │   ├── button
--   │   ├── button
--   │   ├── label.year
--   │   ╰── button
--   ╰── grid
--       ╰── label[.day-name][.week-number][.day-number][.other-month][.today]
--   </pre>
--   
--   <tt>GtkCalendar</tt> has a main node with name calendar. It contains a
--   subnode called header containing the widgets for switching between
--   years and months.
--   
--   The grid subnode contains all day labels, including week numbers on
--   the left (marked with the .week-number css class) and day names on top
--   (marked with the .day-name css class).
--   
--   Day labels that belong to the previous or next month get the
--   .other-month style class. The label of the current day get the .today
--   style class.
--   
--   Marked day labels get the :selected state assigned.
module GI.Gtk.Objects.Calendar

-- | Memory-managed wrapper type.
newtype Calendar
Calendar :: ManagedPtr Calendar -> Calendar

-- | Type class for types which can be safely cast to <a>Calendar</a>, for
--   instance with <a>toCalendar</a>.
class (GObject o, IsDescendantOf Calendar o) => IsCalendar o

-- | Cast to <a>Calendar</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCalendar :: (MonadIO m, IsCalendar o) => o -> m Calendar

-- | Remove all visual markers.
calendarClearMarks :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m ()

-- | Returns a <tt>GDateTime</tt> representing the shown year, month and
--   the selected day.
--   
--   The returned date is in the local time zone.
calendarGetDate :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m DateTime

-- | Gets the day of the selected date.
--   
--   <i>Since: 4.14</i>
calendarGetDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Int32

-- | Returns if the <i><tt>day</tt></i> of the <i><tt>calendar</tt></i> is
--   already marked.
calendarGetDayIsMarked :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m Bool

-- | Gets the month of the selected date.
--   
--   <i>Since: 4.14</i>
calendarGetMonth :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Int32

-- | Returns whether <i><tt>self</tt></i> is currently showing the names of
--   the week days.
--   
--   This is the value of the <a>Calendar:showDayNames</a> property.
calendarGetShowDayNames :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Bool

-- | Returns whether <i><tt>self</tt></i> is currently showing the heading.
--   
--   This is the value of the <a>Calendar:showHeading</a> property.
calendarGetShowHeading :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Bool

-- | Returns whether <i><tt>self</tt></i> is showing week numbers right
--   now.
--   
--   This is the value of the <a>Calendar:showWeekNumbers</a> property.
calendarGetShowWeekNumbers :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Bool

-- | Gets the year of the selected date.
--   
--   <i>Since: 4.14</i>
calendarGetYear :: (HasCallStack, MonadIO m, IsCalendar a) => a -> m Int32

-- | Places a visual marker on a particular day of the current month.
calendarMarkDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m ()

-- | Creates a new calendar, with the current date being selected.
calendarNew :: (HasCallStack, MonadIO m) => m Calendar

-- | Switches to <i><tt>date</tt></i>'s year and month and select its day.

-- | <i>Deprecated: (Since version 4.20)Use
--   [method<i><tt>calendar</tt></i>.set_date] instead.</i>
calendarSelectDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> DateTime -> m ()

-- | Switches to <i><tt>date</tt></i>'s year and month and selects its day.
--   
--   <i>Since: 4.20</i>
calendarSetDate :: (HasCallStack, MonadIO m, IsCalendar a) => a -> DateTime -> m ()

-- | Sets the day for the selected date.
--   
--   The new date must be valid. For example, setting the day to 31 when
--   the month is February will fail.
--   
--   <i>Since: 4.14</i>
calendarSetDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Int32 -> m ()

-- | Sets the month for the selected date.
--   
--   The new date must be valid. For example, setting the month to 1
--   (February) when the day is 31 will fail.
--   
--   <i>Since: 4.14</i>
calendarSetMonth :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Int32 -> m ()

-- | Sets whether the calendar shows day names.
calendarSetShowDayNames :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Bool -> m ()

-- | Sets whether the calendar should show a heading.
--   
--   The heading contains the current year and month as well as buttons for
--   changing both.
calendarSetShowHeading :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Bool -> m ()

-- | Sets whether week numbers are shown in the calendar.
calendarSetShowWeekNumbers :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Bool -> m ()

-- | Sets the year for the selected date.
--   
--   The new date must be valid. For example, setting the year to 2023 when
--   the date is February 29 will fail.
--   
--   <i>Since: 4.14</i>
calendarSetYear :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Int32 -> m ()

-- | Removes the visual marker from a particular day.
calendarUnmarkDay :: (HasCallStack, MonadIO m, IsCalendar a) => a -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>date</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCalendarDate :: (IsCalendar o, MonadIO m) => DateTime -> m (GValueConstruct o)

-- | Get the value of the “<tt>date</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #date
--   </pre>
getCalendarDate :: (MonadIO m, IsCalendar o) => o -> m (Maybe DateTime)

-- | Set the value of the “<tt>date</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #date <a>:=</a> value ]
--   </pre>
setCalendarDate :: (MonadIO m, IsCalendar o) => o -> DateTime -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>day</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCalendarDay :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>day</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #day
--   </pre>
getCalendarDay :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>day</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #day <a>:=</a> value ]
--   </pre>
setCalendarDay :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>month</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCalendarMonth :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>month</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #month
--   </pre>
getCalendarMonth :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>month</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #month <a>:=</a> value ]
--   </pre>
setCalendarMonth :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-day-names</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCalendarShowDayNames :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-day-names</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #showDayNames
--   </pre>
getCalendarShowDayNames :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>show-day-names</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #showDayNames <a>:=</a> value ]
--   </pre>
setCalendarShowDayNames :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-heading</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCalendarShowHeading :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #showHeading
--   </pre>
getCalendarShowHeading :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>show-heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #showHeading <a>:=</a> value ]
--   </pre>
setCalendarShowHeading :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-week-numbers</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCalendarShowWeekNumbers :: (IsCalendar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-week-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #showWeekNumbers
--   </pre>
getCalendarShowWeekNumbers :: (MonadIO m, IsCalendar o) => o -> m Bool

-- | Set the value of the “<tt>show-week-numbers</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #showWeekNumbers <a>:=</a> value ]
--   </pre>
setCalendarShowWeekNumbers :: (MonadIO m, IsCalendar o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>year</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCalendarYear :: (IsCalendar o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>year</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> calendar #year
--   </pre>
getCalendarYear :: (MonadIO m, IsCalendar o) => o -> m Int32

-- | Set the value of the “<tt>year</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> calendar [ #year <a>:=</a> value ]
--   </pre>
setCalendarYear :: (MonadIO m, IsCalendar o) => o -> Int32 -> m ()

-- | Emitted when the user selects a day.
type CalendarDaySelectedCallback = IO ()

-- | Connect a signal handler for the <a>daySelected</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #daySelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarDaySelected :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>daySelected</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #daySelected callback
--   </pre>
onCalendarDaySelected :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarDaySelectedCallback) -> m SignalHandlerId

-- | Emitted when the user switches to the next month.
type CalendarNextMonthCallback = IO ()

-- | Connect a signal handler for the <a>nextMonth</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #nextMonth callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarNextMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextMonth</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #nextMonth callback
--   </pre>
onCalendarNextMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextMonthCallback) -> m SignalHandlerId

-- | Emitted when user switches to the next year.
type CalendarNextYearCallback = IO ()

-- | Connect a signal handler for the <a>nextYear</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #nextYear callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarNextYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>nextYear</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #nextYear callback
--   </pre>
onCalendarNextYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarNextYearCallback) -> m SignalHandlerId

-- | Emitted when the user switches to the previous month.
type CalendarPrevMonthCallback = IO ()

-- | Connect a signal handler for the <a>prevMonth</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #prevMonth callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarPrevMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevMonthCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prevMonth</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #prevMonth callback
--   </pre>
onCalendarPrevMonth :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevMonthCallback) -> m SignalHandlerId

-- | Emitted when user switches to the previous year.
type CalendarPrevYearCallback = IO ()

-- | Connect a signal handler for the <a>prevYear</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> calendar #prevYear callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCalendarPrevYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevYearCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prevYear</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> calendar #prevYear callback
--   </pre>
onCalendarPrevYear :: (IsCalendar a, MonadIO m) => a -> ((?self :: a) => CalendarPrevYearCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Calendar.Calendar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Calendar.Calendar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Calendar.Calendar
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Calendar.Calendar o) => GI.Gtk.Objects.Calendar.IsCalendar o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Calendar.Calendar)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Calendar.Calendar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Calendar.Calendar


-- | A variant of <tt>GtkClosureExpression</tt> using a C closure.
module GI.Gtk.Objects.CClosureExpression

-- | Memory-managed wrapper type.
newtype CClosureExpression
CClosureExpression :: ManagedPtr CClosureExpression -> CClosureExpression

-- | Type class for types which can be safely cast to
--   <a>CClosureExpression</a>, for instance with
--   <a>toCClosureExpression</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf CClosureExpression o) => IsCClosureExpression o

-- | Cast to <a>CClosureExpression</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCClosureExpression :: (MonadIO m, IsCClosureExpression o) => o -> m CClosureExpression

-- | Creates a <tt>GtkExpression</tt> that calls <tt>callback_func</tt>
--   when it is evaluated.
--   
--   This function is a variant of <a>closureExpressionNew</a> that creates
--   a <tt>GClosure</tt> by calling <tt><i>g_cclosure_new()</i></tt> with
--   the given <tt>callback_func</tt>, <tt>user_data</tt> and
--   <tt>user_destroy</tt>.
cClosureExpressionNew :: (HasCallStack, MonadIO m) => GType -> Maybe ClosureMarshal -> [Expression] -> Callback -> m CClosureExpression
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Objects.CClosureExpression.CClosureExpression
instance GHC.Classes.Eq GI.Gtk.Objects.CClosureExpression.CClosureExpression
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.CClosureExpression.CClosureExpression
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.CClosureExpression.CClosureExpression o) => GI.Gtk.Objects.CClosureExpression.IsCClosureExpression o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.CClosureExpression.CClosureExpression
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.CClosureExpression.CClosureExpression


-- | Calls a callback function when the button is clicked.
--   
--   &lt;picture&gt; &lt;source srcset="button-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkButton" src="button.png"&gt; &lt;/picture&gt;
--   
--   The <tt>GtkButton</tt> widget can hold any valid child widget. That
--   is, it can hold almost any other standard <tt>GtkWidget</tt>. The most
--   commonly used child is the <tt>GtkLabel</tt>.
--   
--   <h1>Shortcuts and Gestures</h1>
--   
--   The following signals have default keybindings:
--   
--   <ul>
--   <li><a>Button::activate</a></li>
--   </ul>
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkButton</tt> has a single CSS node with name button. The node
--   will get the style classes .image-button or .text-button, if the
--   content is just an image or label, respectively. It may also receive
--   the .flat style class. When activating a button via the keyboard, the
--   button will temporarily gain the .keyboard-activating style class.
--   
--   Other style classes that are commonly used with <tt>GtkButton</tt>
--   include .suggested-action and .destructive-action. In special cases,
--   buttons can be made round by adding the .circular style class.
--   
--   Button-like widgets like <a>ToggleButton</a>, <a>MenuButton</a>,
--   <a>VolumeButton</a>, <a>LockButton</a>, <a>ColorButton</a> or
--   <a>FontButton</a> use style classes such as .toggle, .popup, .scale,
--   .lock, .color on the button node to differentiate themselves from a
--   plain <tt>GtkButton</tt>.
--   
--   <h1>Accessibility</h1>
--   
--   <tt>GtkButton</tt> uses the <a>AccessibleRoleButton</a> role.
module GI.Gtk.Objects.Button

-- | Memory-managed wrapper type.
newtype Button
Button :: ManagedPtr Button -> Button

-- | Type class for types which can be safely cast to <a>Button</a>, for
--   instance with <a>toButton</a>.
class (GObject o, IsDescendantOf Button o) => IsButton o

-- | Cast to <a>Button</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toButton :: (MonadIO m, IsButton o) => o -> m Button

-- | Retrieves whether the button can be smaller than the natural size of
--   its contents.
--   
--   <i>Since: 4.12</i>
buttonGetCanShrink :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Gets the child widget of <i><tt>button</tt></i>.
buttonGetChild :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Maybe Widget)

-- | Returns whether the button has a frame.
buttonGetHasFrame :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Returns the icon name of the button.
--   
--   If the icon name has not been set with <a>buttonSetIconName</a> the
--   return value will be <a>Nothing</a>. This will be the case if you
--   create an empty button with <a>buttonNew</a> to use as a container.
buttonGetIconName :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Maybe Text)

-- | Fetches the text from the label of the button.
--   
--   If the label text has not been set with <a>buttonSetLabel</a> the
--   return value will be <a>Nothing</a>. This will be the case if you
--   create an empty button with <a>buttonNew</a> to use as a container.
buttonGetLabel :: (HasCallStack, MonadIO m, IsButton a) => a -> m (Maybe Text)

-- | gets whether underlines are interpreted as mnemonics.
--   
--   See <a>buttonSetUseUnderline</a>.
buttonGetUseUnderline :: (HasCallStack, MonadIO m, IsButton a) => a -> m Bool

-- | Creates a new <tt>GtkButton</tt> widget.
--   
--   To add a child widget to the button, use <a>buttonSetChild</a>.
buttonNew :: (HasCallStack, MonadIO m) => m Button

-- | Creates a new button containing an icon from the current icon theme.
--   
--   If the icon name isn’t known, a “broken image” icon will be displayed
--   instead. If the current icon theme is changed, the icon will be
--   updated appropriately.
buttonNewFromIconName :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Creates a <tt>GtkButton</tt> widget with a <tt>GtkLabel</tt> child.
buttonNewWithLabel :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Creates a new <tt>GtkButton</tt> containing a label.
--   
--   If characters in <i><tt>label</tt></i> are preceded by an underscore,
--   they are underlined. If you need a literal underscore character in a
--   label, use “__” (two underscores). The first underlined character
--   represents a keyboard accelerator called a mnemonic. Pressing
--   &lt;kbd&gt;Alt&lt;/kbd&gt; and that key activates the button.
buttonNewWithMnemonic :: (HasCallStack, MonadIO m) => Text -> m Button

-- | Sets whether the button size can be smaller than the natural size of
--   its contents.
--   
--   For text buttons, setting <i><tt>canShrink</tt></i> to true will
--   ellipsize the label.
--   
--   For icons and custom children, this function has no effect.
--   
--   <i>Since: 4.12</i>
buttonSetCanShrink :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Sets the child widget of <i><tt>button</tt></i>.
--   
--   Note that by using this API, you take full responsibility for setting
--   up the proper accessibility label and description information for
--   <i><tt>button</tt></i>. Most likely, you'll either set the
--   accessibility label or description for <i><tt>button</tt></i>
--   explicitly, or you'll set a labelled-by or described-by relations from
--   <i><tt>child</tt></i> to <i><tt>button</tt></i>.
buttonSetChild :: (HasCallStack, MonadIO m, IsButton a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets the style of the button.
--   
--   Buttons can have a flat appearance or have a frame drawn around them.
buttonSetHasFrame :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Adds a <tt>GtkImage</tt> with the given icon name as a child.
--   
--   If <i><tt>button</tt></i> already contains a child widget, that child
--   widget will be removed and replaced with the image.
buttonSetIconName :: (HasCallStack, MonadIO m, IsButton a) => a -> Text -> m ()

-- | Sets the text of the label of the button to <i><tt>label</tt></i>.
--   
--   This will also clear any previously set labels.
buttonSetLabel :: (HasCallStack, MonadIO m, IsButton a) => a -> Text -> m ()

-- | Sets whether to use underlines as mnemonics.
--   
--   If true, an underline in the text of the button label indicates the
--   next character should be used for the mnemonic accelerator key.
buttonSetUseUnderline :: (HasCallStack, MonadIO m, IsButton a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>can-shrink</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructButtonCanShrink :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>can-shrink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #canShrink
--   </pre>
getButtonCanShrink :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “<tt>can-shrink</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #canShrink <a>:=</a> value ]
--   </pre>
setButtonCanShrink :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearButtonChild :: (MonadIO m, IsButton o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructButtonChild :: (IsButton o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #child
--   </pre>
getButtonChild :: (MonadIO m, IsButton o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #child <a>:=</a> value ]
--   </pre>
setButtonChild :: (MonadIO m, IsButton o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>has-frame</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructButtonHasFrame :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #hasFrame
--   </pre>
getButtonHasFrame :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “<tt>has-frame</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #hasFrame <a>:=</a> value ]
--   </pre>
setButtonHasFrame :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>icon-name</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructButtonIconName :: (IsButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #iconName
--   </pre>
getButtonIconName :: (MonadIO m, IsButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #iconName <a>:=</a> value ]
--   </pre>
setButtonIconName :: (MonadIO m, IsButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>label</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructButtonLabel :: (IsButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #label
--   </pre>
getButtonLabel :: (MonadIO m, IsButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #label <a>:=</a> value ]
--   </pre>
setButtonLabel :: (MonadIO m, IsButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-underline</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructButtonUseUnderline :: (IsButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> button #useUnderline
--   </pre>
getButtonUseUnderline :: (MonadIO m, IsButton o) => o -> m Bool

-- | Set the value of the “<tt>use-underline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> button [ #useUnderline <a>:=</a> value ]
--   </pre>
setButtonUseUnderline :: (MonadIO m, IsButton o) => o -> Bool -> m ()

-- | Emitted to animate press then release.
--   
--   This is an action signal. Applications should never connect to this
--   signal, but use the <a>Button::clicked</a> signal.
--   
--   The default bindings for this signal are all forms of the
--   &lt;kbd&gt;␣&lt;/kbd&gt; and &lt;kbd&gt;Enter&lt;/kbd&gt; keys.
type ButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonActivate :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> button #activate callback
--   </pre>
onButtonActivate :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonActivateCallback) -> m SignalHandlerId

-- | Emitted when the button has been activated (pressed and released).
type ButtonClickedCallback = IO ()

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> button #clicked callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterButtonClicked :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonClickedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>clicked</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> button #clicked callback
--   </pre>
onButtonClicked :: (IsButton a, MonadIO m) => a -> ((?self :: a) => ButtonClickedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Button.Button
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Button.Button
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Button.Button
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Button.Button o) => GI.Gtk.Objects.Button.IsButton o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Button.Button)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Button.Button
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Button.Button


-- | Arranges children in a single row or column.
--   
--   Whether it is a row or column depends on the value of its
--   <a>Orientable:orientation</a> property. Within the other dimension all
--   children all allocated the same size. The <tt>GtkBoxLayout</tt> will
--   respect the <a>Widget:halign</a> and <a>Widget:valign</a> properties
--   of each child widget.
--   
--   If you want all children to be assigned the same size, you can use the
--   <a>BoxLayout:homogeneous</a> property.
--   
--   If you want to specify the amount of space placed between each child,
--   you can use the <a>BoxLayout:spacing</a> property.
module GI.Gtk.Objects.BoxLayout

-- | Memory-managed wrapper type.
newtype BoxLayout
BoxLayout :: ManagedPtr BoxLayout -> BoxLayout

-- | Type class for types which can be safely cast to <a>BoxLayout</a>, for
--   instance with <a>toBoxLayout</a>.
class (GObject o, IsDescendantOf BoxLayout o) => IsBoxLayout o

-- | Cast to <a>BoxLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBoxLayout :: (MonadIO m, IsBoxLayout o) => o -> m BoxLayout

-- | Gets the value set by <a>boxLayoutSetBaselineChild</a>.
--   
--   <i>Since: 4.12</i>
boxLayoutGetBaselineChild :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> m Int32

-- | Gets the value set by <a>boxLayoutSetBaselinePosition</a>.
boxLayoutGetBaselinePosition :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> m BaselinePosition

-- | Returns whether the layout is set to be homogeneous.
boxLayoutGetHomogeneous :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> m Bool

-- | Returns the space that <i><tt>boxLayout</tt></i> puts between
--   children.
boxLayoutGetSpacing :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> m Word32

-- | Creates a new <tt>GtkBoxLayout</tt>.
boxLayoutNew :: (HasCallStack, MonadIO m) => Orientation -> m BoxLayout

-- | Sets the index of the child that determines the baseline in vertical
--   layout.
--   
--   <i>Since: 4.12</i>
boxLayoutSetBaselineChild :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> Int32 -> m ()

-- | Sets the baseline position of a box layout.
--   
--   The baseline position affects only horizontal boxes with at least one
--   baseline aligned child. If there is more vertical space available than
--   requested, and the baseline is not allocated by the parent then the
--   given <i><tt>position</tt></i> is used to allocate the baseline within
--   the extra space available.
boxLayoutSetBaselinePosition :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> BaselinePosition -> m ()

-- | Sets whether the box layout will allocate the same size to all
--   children.
boxLayoutSetHomogeneous :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> Bool -> m ()

-- | Sets how much spacing to put between children.
boxLayoutSetSpacing :: (HasCallStack, MonadIO m, IsBoxLayout a) => a -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-child</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBoxLayoutBaselineChild :: (IsBoxLayout o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> boxLayout #baselineChild
--   </pre>
getBoxLayoutBaselineChild :: (MonadIO m, IsBoxLayout o) => o -> m Int32

-- | Set the value of the “<tt>baseline-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> boxLayout [ #baselineChild <a>:=</a> value ]
--   </pre>
setBoxLayoutBaselineChild :: (MonadIO m, IsBoxLayout o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-position</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBoxLayoutBaselinePosition :: (IsBoxLayout o, MonadIO m) => BaselinePosition -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> boxLayout #baselinePosition
--   </pre>
getBoxLayoutBaselinePosition :: (MonadIO m, IsBoxLayout o) => o -> m BaselinePosition

-- | Set the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> boxLayout [ #baselinePosition <a>:=</a> value ]
--   </pre>
setBoxLayoutBaselinePosition :: (MonadIO m, IsBoxLayout o) => o -> BaselinePosition -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>homogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructBoxLayoutHomogeneous :: (IsBoxLayout o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> boxLayout #homogeneous
--   </pre>
getBoxLayoutHomogeneous :: (MonadIO m, IsBoxLayout o) => o -> m Bool

-- | Set the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> boxLayout [ #homogeneous <a>:=</a> value ]
--   </pre>
setBoxLayoutHomogeneous :: (MonadIO m, IsBoxLayout o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBoxLayoutSpacing :: (IsBoxLayout o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> boxLayout #spacing
--   </pre>
getBoxLayoutSpacing :: (MonadIO m, IsBoxLayout o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> boxLayout [ #spacing <a>:=</a> value ]
--   </pre>
setBoxLayoutSpacing :: (MonadIO m, IsBoxLayout o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.BoxLayout.BoxLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.BoxLayout.BoxLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.BoxLayout.BoxLayout
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.BoxLayout.BoxLayout o) => GI.Gtk.Objects.BoxLayout.IsBoxLayout o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.BoxLayout.BoxLayout)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.BoxLayout.BoxLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.BoxLayout.BoxLayout


-- | Arranges child widgets into a single row or column.
--   
--   &lt;picture&gt; &lt;source srcset="box-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkBox" src="box.png"&gt; &lt;/picture&gt;
--   
--   Whether it is a row or column depends on the value of its
--   <a>Orientable:orientation</a> property. Within the other dimension,
--   all children are allocated the same size. The <a>Widget:halign</a> and
--   <a>Widget:valign</a> properties can be used on the children to
--   influence their allocation.
--   
--   Use repeated calls to <a>boxAppend</a> to pack widgets into a
--   <tt>GtkBox</tt> from start to end. Use <a>boxRemove</a> to remove
--   widgets from the <tt>GtkBox</tt>. <a>boxInsertChildAfter</a> can be
--   used to add a child at a particular position.
--   
--   Use <a>boxSetHomogeneous</a> to specify whether or not all children of
--   the <tt>GtkBox</tt> are forced to get the same amount of space.
--   
--   Use <a>boxSetSpacing</a> to determine how much space will be minimally
--   placed between all children in the <tt>GtkBox</tt>. Note that spacing
--   is added *between* the children.
--   
--   Use <a>boxReorderChildAfter</a> to move a child to a different place
--   in the box.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkBox</tt> uses a single CSS node with name box.
--   
--   <h1>Accessibility</h1>
--   
--   Until GTK 4.10, <tt>GtkBox</tt> used the <a>AccessibleRoleGroup</a>
--   role.
--   
--   Starting from GTK 4.12, <tt>GtkBox</tt> uses the
--   <a>AccessibleRoleGeneric</a> role.
module GI.Gtk.Objects.Box

-- | Memory-managed wrapper type.
newtype Box
Box :: ManagedPtr Box -> Box

-- | Type class for types which can be safely cast to <a>Box</a>, for
--   instance with <a>toBox</a>.
class (GObject o, IsDescendantOf Box o) => IsBox o

-- | Cast to <a>Box</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toBox :: (MonadIO m, IsBox o) => o -> m Box

-- | Adds a child at the end.
boxAppend :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> m ()

-- | Gets the value set by <a>boxSetBaselineChild</a>.
--   
--   <i>Since: 4.12</i>
boxGetBaselineChild :: (HasCallStack, MonadIO m, IsBox a) => a -> m Int32

-- | Gets the value set by <a>boxSetBaselinePosition</a>.
boxGetBaselinePosition :: (HasCallStack, MonadIO m, IsBox a) => a -> m BaselinePosition

-- | Returns whether the box is homogeneous.
--   
--   In a homogeneous box all children are the same size.
boxGetHomogeneous :: (HasCallStack, MonadIO m, IsBox a) => a -> m Bool

-- | Gets the value set by <a>boxSetSpacing</a>.
boxGetSpacing :: (HasCallStack, MonadIO m, IsBox a) => a -> m Int32

-- | Inserts a child at a specific position.
--   
--   The child is added after <i><tt>sibling</tt></i> in the list of
--   <i><tt>box</tt></i> children.
--   
--   If <i><tt>sibling</tt></i> is <tt>NULL</tt>, the <i><tt>child</tt></i>
--   is placed at the beginning.
boxInsertChildAfter :: (HasCallStack, MonadIO m, IsBox a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Creates a new box.
boxNew :: (HasCallStack, MonadIO m) => Orientation -> Int32 -> m Box

-- | Adds a child at the beginning.
boxPrepend :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> m ()

-- | Removes a child widget from the box.
--   
--   The child must have been added before with <a>boxAppend</a>,
--   <a>boxPrepend</a>, or <a>boxInsertChildAfter</a>.
boxRemove :: (HasCallStack, MonadIO m, IsBox a, IsWidget b) => a -> b -> m ()

-- | Moves a child to a different position.
--   
--   The child is moved to the position after <i><tt>sibling</tt></i> in
--   the list of <i><tt>box</tt></i> children.
--   
--   If <i><tt>sibling</tt></i> is <tt>NULL</tt>, the child is placed at
--   the beginning.
boxReorderChildAfter :: (HasCallStack, MonadIO m, IsBox a, IsWidget b, IsWidget c) => a -> b -> Maybe c -> m ()

-- | Sets the baseline child of a box.
--   
--   This affects only vertical boxes.
--   
--   <i>Since: 4.12</i>
boxSetBaselineChild :: (HasCallStack, MonadIO m, IsBox a) => a -> Int32 -> m ()

-- | Sets the baseline position of a box.
--   
--   This affects only horizontal boxes with at least one baseline aligned
--   child. If there is more vertical space available than requested, and
--   the baseline is not allocated by the parent then
--   <i><tt>position</tt></i> is used to allocate the baseline with respect
--   to the extra space available.
boxSetBaselinePosition :: (HasCallStack, MonadIO m, IsBox a) => a -> BaselinePosition -> m ()

-- | Sets whether or not all children are given equal space in the box.
boxSetHomogeneous :: (HasCallStack, MonadIO m, IsBox a) => a -> Bool -> m ()

-- | Sets the number of pixels to place between children.
boxSetSpacing :: (HasCallStack, MonadIO m, IsBox a) => a -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-child</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBoxBaselineChild :: (IsBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> box #baselineChild
--   </pre>
getBoxBaselineChild :: (MonadIO m, IsBox o) => o -> m Int32

-- | Set the value of the “<tt>baseline-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> box [ #baselineChild <a>:=</a> value ]
--   </pre>
setBoxBaselineChild :: (MonadIO m, IsBox o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline-position</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBoxBaselinePosition :: (IsBox o, MonadIO m) => BaselinePosition -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> box #baselinePosition
--   </pre>
getBoxBaselinePosition :: (MonadIO m, IsBox o) => o -> m BaselinePosition

-- | Set the value of the “<tt>baseline-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> box [ #baselinePosition <a>:=</a> value ]
--   </pre>
setBoxBaselinePosition :: (MonadIO m, IsBox o) => o -> BaselinePosition -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>homogeneous</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructBoxHomogeneous :: (IsBox o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> box #homogeneous
--   </pre>
getBoxHomogeneous :: (MonadIO m, IsBox o) => o -> m Bool

-- | Set the value of the “<tt>homogeneous</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> box [ #homogeneous <a>:=</a> value ]
--   </pre>
setBoxHomogeneous :: (MonadIO m, IsBox o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>spacing</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBoxSpacing :: (IsBox o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> box #spacing
--   </pre>
getBoxSpacing :: (MonadIO m, IsBox o) => o -> m Int32

-- | Set the value of the “<tt>spacing</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> box [ #spacing <a>:=</a> value ]
--   </pre>
setBoxSpacing :: (MonadIO m, IsBox o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.Box.Box
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Box.Box
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Box.Box
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Box.Box o) => GI.Gtk.Objects.Box.IsBox o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Box.Box)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Box.Box
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Box.Box


-- | Evaluates a boolean expression to determine whether to include items.
module GI.Gtk.Objects.BoolFilter

-- | Memory-managed wrapper type.
newtype BoolFilter
BoolFilter :: ManagedPtr BoolFilter -> BoolFilter

-- | Type class for types which can be safely cast to <a>BoolFilter</a>,
--   for instance with <a>toBoolFilter</a>.
class (GObject o, IsDescendantOf BoolFilter o) => IsBoolFilter o

-- | Cast to <a>BoolFilter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBoolFilter :: (MonadIO m, IsBoolFilter o) => o -> m BoolFilter

-- | Gets the expression that the filter evaluates for each item.
boolFilterGetExpression :: (HasCallStack, MonadIO m, IsBoolFilter a) => a -> m (Maybe Expression)

-- | Returns whether the filter inverts the expression.
boolFilterGetInvert :: (HasCallStack, MonadIO m, IsBoolFilter a) => a -> m Bool

-- | Creates a new bool filter.
boolFilterNew :: (HasCallStack, MonadIO m, IsExpression a) => Maybe a -> m BoolFilter

-- | Sets the expression that the filter uses to check if items should be
--   filtered.
--   
--   The expression must have a value type of <tt>G_TYPE_BOOLEAN</tt>.
boolFilterSetExpression :: (HasCallStack, MonadIO m, IsBoolFilter a, IsExpression b) => a -> Maybe b -> m ()

-- | Sets whether the filter should invert the expression.
boolFilterSetInvert :: (HasCallStack, MonadIO m, IsBoolFilter a) => a -> Bool -> m ()

-- | Set the value of the “<tt>expression</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #expression
--   </pre>
clearBoolFilterExpression :: (MonadIO m, IsBoolFilter o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>expression</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructBoolFilterExpression :: (IsBoolFilter o, MonadIO m, IsExpression a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> boolFilter #expression
--   </pre>
getBoolFilterExpression :: (MonadIO m, IsBoolFilter o) => o -> m (Maybe Expression)

-- | Set the value of the “<tt>expression</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> boolFilter [ #expression <a>:=</a> value ]
--   </pre>
setBoolFilterExpression :: (MonadIO m, IsBoolFilter o, IsExpression a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>invert</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBoolFilterInvert :: (IsBoolFilter o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>invert</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> boolFilter #invert
--   </pre>
getBoolFilterInvert :: (MonadIO m, IsBoolFilter o) => o -> m Bool

-- | Set the value of the “<tt>invert</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> boolFilter [ #invert <a>:=</a> value ]
--   </pre>
setBoolFilterInvert :: (MonadIO m, IsBoolFilter o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.BoolFilter.BoolFilter
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.BoolFilter.BoolFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.BoolFilter.BoolFilter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.BoolFilter.BoolFilter o) => GI.Gtk.Objects.BoolFilter.IsBoolFilter o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.BoolFilter.BoolFilter)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.BoolFilter.BoolFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.BoolFilter.BoolFilter


-- | A layout manager for widgets with a single child.
--   
--   <tt>GtkBinLayout</tt> will stack each child of a widget on top of each
--   other, using the <a>Widget:hexpand</a>, <a>Widget:vexpand</a>,
--   <a>Widget:halign</a>, and <a>Widget:valign</a> properties of each
--   child to determine where they should be positioned.
module GI.Gtk.Objects.BinLayout

-- | Memory-managed wrapper type.
newtype BinLayout
BinLayout :: ManagedPtr BinLayout -> BinLayout

-- | Type class for types which can be safely cast to <a>BinLayout</a>, for
--   instance with <a>toBinLayout</a>.
class (GObject o, IsDescendantOf BinLayout o) => IsBinLayout o

-- | Cast to <a>BinLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBinLayout :: (MonadIO m, IsBinLayout o) => o -> m BinLayout

-- | Creates a new <tt>GtkBinLayout</tt> instance.
binLayoutNew :: (HasCallStack, MonadIO m) => m BinLayout
instance GHC.Classes.Eq GI.Gtk.Objects.BinLayout.BinLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.BinLayout.BinLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.BinLayout.BinLayout
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.BinLayout.BinLayout o) => GI.Gtk.Objects.BinLayout.IsBinLayout o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.BinLayout.BinLayout)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.BinLayout.BinLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.BinLayout.BinLayout


-- | <tt>GtkAssistantPage</tt> is an auxiliary object used by
--   <tt>GtkAssistant</tt>.
module GI.Gtk.Objects.AssistantPage

-- | Memory-managed wrapper type.
newtype AssistantPage
AssistantPage :: ManagedPtr AssistantPage -> AssistantPage

-- | Type class for types which can be safely cast to <a>AssistantPage</a>,
--   for instance with <a>toAssistantPage</a>.
class (GObject o, IsDescendantOf AssistantPage o) => IsAssistantPage o

-- | Cast to <a>AssistantPage</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAssistantPage :: (MonadIO m, IsAssistantPage o) => o -> m AssistantPage

-- | Returns the child to which <i><tt>page</tt></i> belongs.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantPageGetChild :: (HasCallStack, MonadIO m, IsAssistantPage a) => a -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAssistantPageChild :: (IsAssistantPage o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> assistantPage #child
--   </pre>
getAssistantPageChild :: (MonadIO m, IsAssistantPage o) => o -> m Widget

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>complete</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAssistantPageComplete :: (IsAssistantPage o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>complete</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> assistantPage #complete
--   </pre>
getAssistantPageComplete :: (MonadIO m, IsAssistantPage o) => o -> m Bool

-- | Set the value of the “<tt>complete</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> assistantPage [ #complete <a>:=</a> value ]
--   </pre>
setAssistantPageComplete :: (MonadIO m, IsAssistantPage o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>page-type</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAssistantPagePageType :: (IsAssistantPage o, MonadIO m) => AssistantPageType -> m (GValueConstruct o)

-- | Get the value of the “<tt>page-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> assistantPage #pageType
--   </pre>
getAssistantPagePageType :: (MonadIO m, IsAssistantPage o) => o -> m AssistantPageType

-- | Set the value of the “<tt>page-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> assistantPage [ #pageType <a>:=</a> value ]
--   </pre>
setAssistantPagePageType :: (MonadIO m, IsAssistantPage o) => o -> AssistantPageType -> m ()

-- | Set the value of the “<tt>title</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #title
--   </pre>
clearAssistantPageTitle :: (MonadIO m, IsAssistantPage o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>title</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAssistantPageTitle :: (IsAssistantPage o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> assistantPage #title
--   </pre>
getAssistantPageTitle :: (MonadIO m, IsAssistantPage o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>title</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> assistantPage [ #title <a>:=</a> value ]
--   </pre>
setAssistantPageTitle :: (MonadIO m, IsAssistantPage o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.AssistantPage.AssistantPage
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AssistantPage.AssistantPage
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AssistantPage.AssistantPage
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AssistantPage.AssistantPage o) => GI.Gtk.Objects.AssistantPage.IsAssistantPage o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AssistantPage.AssistantPage)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AssistantPage.AssistantPage
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AssistantPage.AssistantPage


-- | <tt>GtkAssistant</tt> is used to represent a complex as a series of
--   steps.
--   
--   &lt;picture&gt; &lt;source srcset="assistant-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkAssistant" src="assistant.png"&gt; &lt;/picture&gt;
--   
--   Each step consists of one or more pages. <tt>GtkAssistant</tt> guides
--   the user through the pages, and controls the page flow to collect the
--   data needed for the operation.
--   
--   <tt>GtkAssistant</tt> handles which buttons to show and to make
--   sensitive based on page sequence knowledge and the
--   <a>AssistantPageType</a> of each page in addition to state information
--   like the *completed* and *committed* page statuses.
--   
--   If you have a case that doesn’t quite fit in <tt>GtkAssistant</tt>s
--   way of handling buttons, you can use the
--   <a>AssistantPageTypeCustom</a> page type and handle buttons yourself.
--   
--   <tt>GtkAssistant</tt> maintains a <tt>GtkAssistantPage</tt> object for
--   each added child, which holds additional per-child properties. You
--   obtain the <tt>GtkAssistantPage</tt> for a child with
--   <a>assistantGetPage</a>.
--   
--   <h1>GtkAssistant as GtkBuildable</h1>
--   
--   The <tt>GtkAssistant</tt> implementation of the <tt>GtkBuildable</tt>
--   interface exposes the <i><tt>actionArea</tt></i> as internal children
--   with the name “action_area”.
--   
--   To add pages to an assistant in <tt>GtkBuilder</tt>, simply add it as
--   a child to the <tt>GtkAssistant</tt> object. If you need to set
--   per-object properties, create a <tt>GtkAssistantPage</tt> object
--   explicitly, and set the child widget as a property on it.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkAssistant</tt> has a single CSS node with the name window and
--   style class .assistant.
module GI.Gtk.Objects.Assistant

-- | Memory-managed wrapper type.
newtype Assistant
Assistant :: ManagedPtr Assistant -> Assistant

-- | Type class for types which can be safely cast to <a>Assistant</a>, for
--   instance with <a>toAssistant</a>.
class (GObject o, IsDescendantOf Assistant o) => IsAssistant o

-- | Cast to <a>Assistant</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAssistant :: (MonadIO m, IsAssistant o) => o -> m Assistant

-- | Adds a widget to the action area of a <tt>GtkAssistant</tt>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantAddActionWidget :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m ()

-- | Appends a page to the <i><tt>assistant</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantAppendPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Int32

-- | Erases the visited page history.
--   
--   GTK will then hide the back button on the current page, and removes
--   the cancel button from subsequent pages.
--   
--   Use this when the information provided up to the current page is
--   hereafter deemed permanent and cannot be modified or undone. For
--   example, showing a progress page to track a long-running, unreversible
--   operation after the user has clicked apply on a confirmation page.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantCommit :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Returns the page number of the current page.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetCurrentPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m Int32

-- | Returns the number of pages in the <i><tt>assistant</tt></i>

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetNPages :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m Int32

-- | Returns the child widget contained in page number
--   <i><tt>pageNum</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetNthPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m (Maybe Widget)

-- | Returns the <tt>GtkAssistantPage</tt> object for
--   <i><tt>child</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m AssistantPage

-- | Gets whether <i><tt>page</tt></i> is complete.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetPageComplete :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Bool

-- | Gets the title for <i><tt>page</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetPageTitle :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Text

-- | Gets the page type of <i><tt>page</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetPageType :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m AssistantPageType

-- | Gets a list model of the assistant pages.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantGetPages :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ListModel

-- | Inserts a page in the <i><tt>assistant</tt></i> at a given position.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantInsertPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Int32 -> m Int32

-- | Creates a new <tt>GtkAssistant</tt>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantNew :: (HasCallStack, MonadIO m) => m Assistant

-- | Navigate to the next page.
--   
--   It is a programming error to call this function when there is no next
--   page.
--   
--   This function is for use when creating pages of the
--   <a>AssistantPageTypeCustom</a> type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantNextPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Prepends a page to the <i><tt>assistant</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantPrependPage :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m Int32

-- | Navigate to the previous visited page.
--   
--   It is a programming error to call this function when no previous page
--   is available.
--   
--   This function is for use when creating pages of the
--   <a>AssistantPageTypeCustom</a> type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantPreviousPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Removes a widget from the action area of a <tt>GtkAssistant</tt>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantRemoveActionWidget :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> m ()

-- | Removes the <i><tt>pageNum</tt></i>’s page from
--   <i><tt>assistant</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantRemovePage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m ()

-- | Switches the page to <i><tt>pageNum</tt></i>.
--   
--   Note that this will only be necessary in custom buttons, as the
--   <i><tt>assistant</tt></i> flow can be set with
--   <a>assistantSetForwardPageFunc</a>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantSetCurrentPage :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Int32 -> m ()

-- | Sets the page forwarding function to be <i><tt>pageFunc</tt></i>.
--   
--   This function will be used to determine what will be the next page
--   when the user presses the forward button. Setting
--   <i><tt>pageFunc</tt></i> to <a>Nothing</a> will make the assistant to
--   use the default forward function, which just goes to the next visible
--   page.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantSetForwardPageFunc :: (HasCallStack, MonadIO m, IsAssistant a) => a -> Maybe AssistantPageFunc -> m ()

-- | Sets whether <i><tt>page</tt></i> contents are complete.
--   
--   This will make <i><tt>assistant</tt></i> update the buttons state to
--   be able to continue the task.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantSetPageComplete :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Bool -> m ()

-- | Sets a title for <i><tt>page</tt></i>.
--   
--   The title is displayed in the header area of the assistant when
--   <i><tt>page</tt></i> is the current page.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantSetPageTitle :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> Text -> m ()

-- | Sets the page type for <i><tt>page</tt></i>.
--   
--   The page type determines the page behavior in the
--   <i><tt>assistant</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantSetPageType :: (HasCallStack, MonadIO m, IsAssistant a, IsWidget b) => a -> b -> AssistantPageType -> m ()

-- | Forces <i><tt>assistant</tt></i> to recompute the buttons state.
--   
--   GTK automatically takes care of this in most situations, e.g. when the
--   user goes to a different page, or when the visibility or completeness
--   of a page changes.
--   
--   One situation where it can be necessary to call this function is when
--   changing a value on the current page affects the future page flow of
--   the assistant.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
assistantUpdateButtonsState :: (HasCallStack, MonadIO m, IsAssistant a) => a -> m ()

-- | Get the value of the “<tt>pages</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> assistant #pages
--   </pre>
getAssistantPages :: (MonadIO m, IsAssistant o) => o -> m (Maybe ListModel)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>use-header-bar</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAssistantUseHeaderBar :: (IsAssistant o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>use-header-bar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> assistant #useHeaderBar
--   </pre>
getAssistantUseHeaderBar :: (MonadIO m, IsAssistant o) => o -> m Int32

-- | Emitted when the apply button is clicked.
--   
--   The default behavior of the <tt>GtkAssistant</tt> is to switch to the
--   page after the current page, unless the current page is the last one.
--   
--   A handler for the <a>apply</a> signal should carry out the actions for
--   which the wizard has collected data. If the action takes a long time
--   to complete, you might consider putting a page of type
--   <a>AssistantPageTypeProgress</a> after the confirmation page and
--   handle this operation within the <a>Assistant::prepare</a> signal of
--   the progress page.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
type AssistantApplyCallback = IO ()

-- | Connect a signal handler for the <a>apply</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #apply callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantApply :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantApplyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>apply</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> assistant #apply callback
--   </pre>
onAssistantApply :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantApplyCallback) -> m SignalHandlerId

-- | Emitted when then the cancel button is clicked.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
type AssistantCancelCallback = IO ()

-- | Connect a signal handler for the <a>cancel</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #cancel callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantCancel :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCancelCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>cancel</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> assistant #cancel callback
--   </pre>
onAssistantCancel :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCancelCallback) -> m SignalHandlerId

-- | Emitted either when the close button of a summary page is clicked, or
--   when the apply button in the last page in the flow (of type
--   <a>AssistantPageTypeConfirm</a>) is clicked.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
type AssistantCloseCallback = IO ()

-- | Connect a signal handler for the <a>close</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #close callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantClose :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCloseCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>close</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> assistant #close callback
--   </pre>
onAssistantClose :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantCloseCallback) -> m SignalHandlerId

-- | The action signal for the Escape binding.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
type AssistantEscapeCallback = IO ()

-- | Connect a signal handler for the <a>escape</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #escape callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantEscape :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantEscapeCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>escape</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> assistant #escape callback
--   </pre>
onAssistantEscape :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantEscapeCallback) -> m SignalHandlerId

-- | Emitted when a new page is set as the assistant's current page, before
--   making the new page visible.
--   
--   A handler for this signal can do any preparations which are necessary
--   before showing <i><tt>page</tt></i>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
type AssistantPrepareCallback = Widget -> IO ()

-- | Connect a signal handler for the <a>prepare</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> assistant #prepare callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantPrepareCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>prepare</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> assistant #prepare callback
--   </pre>
onAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> ((?self :: a) => AssistantPrepareCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Assistant.Assistant
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Assistant.Assistant
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Assistant.Assistant
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Assistant.Assistant o) => GI.Gtk.Objects.Assistant.IsAssistant o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Assistant.Assistant)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Assistant.Assistant
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Assistant.Assistant


-- | Preserves the aspect ratio of its child.
--   
--   The frame can respect the aspect ratio of the child widget, or use its
--   own aspect ratio.
--   
--   <h1>CSS nodes</h1>
--   
--   <tt>GtkAspectFrame</tt> uses a CSS node with name
--   <tt>aspectframe</tt>.
--   
--   <h1>Accessibility</h1>
--   
--   Until GTK 4.10, <tt>GtkAspectFrame</tt> used the
--   <a>AccessibleRoleGroup</a> role.
--   
--   Starting from GTK 4.12, <tt>GtkAspectFrame</tt> uses the
--   <a>AccessibleRoleGeneric</a> role.
module GI.Gtk.Objects.AspectFrame

-- | Memory-managed wrapper type.
newtype AspectFrame
AspectFrame :: ManagedPtr AspectFrame -> AspectFrame

-- | Type class for types which can be safely cast to <a>AspectFrame</a>,
--   for instance with <a>toAspectFrame</a>.
class (GObject o, IsDescendantOf AspectFrame o) => IsAspectFrame o

-- | Cast to <a>AspectFrame</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAspectFrame :: (MonadIO m, IsAspectFrame o) => o -> m AspectFrame

-- | Gets the child widget of <i><tt>self</tt></i>.
aspectFrameGetChild :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> m (Maybe Widget)

-- | Returns whether the child's size request should override the set
--   aspect ratio of the <tt>GtkAspectFrame</tt>.
aspectFrameGetObeyChild :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> m Bool

-- | Returns the desired aspect ratio of the child.
aspectFrameGetRatio :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> m Float

-- | Returns the horizontal alignment of the child within the allocation of
--   the <tt>GtkAspectFrame</tt>.
aspectFrameGetXalign :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> m Float

-- | Returns the vertical alignment of the child within the allocation of
--   the <tt>GtkAspectFrame</tt>.
aspectFrameGetYalign :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> m Float

-- | Create a new <tt>GtkAspectFrame</tt>.
aspectFrameNew :: (HasCallStack, MonadIO m) => Float -> Float -> Float -> Bool -> m AspectFrame

-- | Sets the child widget of <i><tt>self</tt></i>.
aspectFrameSetChild :: (HasCallStack, MonadIO m, IsAspectFrame a, IsWidget b) => a -> Maybe b -> m ()

-- | Sets whether the aspect ratio of the child's size request should
--   override the set aspect ratio of the <tt>GtkAspectFrame</tt>.
aspectFrameSetObeyChild :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> Bool -> m ()

-- | Sets the desired aspect ratio of the child.
aspectFrameSetRatio :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> Float -> m ()

-- | Sets the horizontal alignment of the child within the allocation of
--   the <tt>GtkAspectFrame</tt>.
aspectFrameSetXalign :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> Float -> m ()

-- | Sets the vertical alignment of the child within the allocation of the
--   <tt>GtkAspectFrame</tt>.
aspectFrameSetYalign :: (HasCallStack, MonadIO m, IsAspectFrame a) => a -> Float -> m ()

-- | Set the value of the “<tt>child</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #child
--   </pre>
clearAspectFrameChild :: (MonadIO m, IsAspectFrame o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>child</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAspectFrameChild :: (IsAspectFrame o, MonadIO m, IsWidget a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #child
--   </pre>
getAspectFrameChild :: (MonadIO m, IsAspectFrame o) => o -> m (Maybe Widget)

-- | Set the value of the “<tt>child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #child <a>:=</a> value ]
--   </pre>
setAspectFrameChild :: (MonadIO m, IsAspectFrame o, IsWidget a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>obey-child</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAspectFrameObeyChild :: (IsAspectFrame o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>obey-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #obeyChild
--   </pre>
getAspectFrameObeyChild :: (MonadIO m, IsAspectFrame o) => o -> m Bool

-- | Set the value of the “<tt>obey-child</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #obeyChild <a>:=</a> value ]
--   </pre>
setAspectFrameObeyChild :: (MonadIO m, IsAspectFrame o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ratio</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAspectFrameRatio :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #ratio
--   </pre>
getAspectFrameRatio :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “<tt>ratio</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #ratio <a>:=</a> value ]
--   </pre>
setAspectFrameRatio :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAspectFrameXalign :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #xalign
--   </pre>
getAspectFrameXalign :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #xalign <a>:=</a> value ]
--   </pre>
setAspectFrameXalign :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>yalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAspectFrameYalign :: (IsAspectFrame o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aspectFrame #yalign
--   </pre>
getAspectFrameYalign :: (MonadIO m, IsAspectFrame o) => o -> m Float

-- | Set the value of the “<tt>yalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aspectFrame [ #yalign <a>:=</a> value ]
--   </pre>
setAspectFrameYalign :: (MonadIO m, IsAspectFrame o) => o -> Float -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.AspectFrame.AspectFrame
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AspectFrame.AspectFrame
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AspectFrame.AspectFrame
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AspectFrame.AspectFrame o) => GI.Gtk.Objects.AspectFrame.IsAspectFrame o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AspectFrame.AspectFrame)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AspectFrame.AspectFrame
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AspectFrame.AspectFrame


-- | A <tt>GtkWindow</tt> subclass that integrates with
--   <tt>GtkApplication</tt>.
--   
--   Notably, <tt>GtkApplicationWindow</tt> can handle an application
--   menubar.
--   
--   This class implements the <a>ActionGroup</a> and <a>ActionMap</a>
--   interfaces, to let you add window-specific actions that will be
--   exported by the associated <a>Application</a>, together with its
--   application-wide actions. Window-specific actions are prefixed with
--   the “win.” prefix and application-wide actions are prefixed with the
--   “app.” prefix. Actions must be addressed with the prefixed name when
--   referring to them from a menu model.
--   
--   Note that widgets that are placed inside a
--   <tt>GtkApplicationWindow</tt> can also activate these actions, if they
--   implement the <a>Actionable</a> interface.
--   
--   The settings <a>Settings:gtkShellShowsAppMenu</a> and
--   <a>Settings:gtkShellShowsMenubar</a> tell GTK whether the desktop
--   environment is showing the application menu and menubar models outside
--   the application as part of the desktop shell. For instance, on OS X,
--   both menus will be displayed remotely; on Windows neither will be.
--   
--   If the desktop environment does not display the menubar, it can be
--   shown in the <tt>GtkApplicationWindow</tt> by setting the
--   <a>ApplicationWindow:showMenubar</a> property to true. If the desktop
--   environment does not display the application menu, then it will
--   automatically be included in the menubar or in the window’s
--   client-side decorations.
--   
--   See <a>PopoverMenu</a> for information about the XML language used by
--   <tt>GtkBuilder</tt> for menu models.
--   
--   See also: <a>applicationSetMenubar</a>.
--   
--   <h2>A GtkApplicationWindow with a menubar</h2>
--   
--   The code sample below shows how to set up a
--   <tt>GtkApplicationWindow</tt> with a menu bar defined on the
--   <a>Application</a>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkApplication *app = gtk_application_new ("org.gtk.test", 0);
--   
--   GtkBuilder *builder = gtk_builder_new_from_string (
--       "&lt;interface&gt;"
--       "  &lt;menu id='menubar'&gt;"
--       "    &lt;submenu&gt;"
--       "      &lt;attribute name='label' translatable='yes'&gt;_Edit&lt;/attribute&gt;"
--       "      &lt;item&gt;"
--       "        &lt;attribute name='label' translatable='yes'&gt;_Copy&lt;/attribute&gt;"
--       "        &lt;attribute name='action'&gt;win.copy&lt;/attribute&gt;"
--       "      &lt;/item&gt;"
--       "      &lt;item&gt;"
--       "        &lt;attribute name='label' translatable='yes'&gt;_Paste&lt;/attribute&gt;"
--       "        &lt;attribute name='action'&gt;win.paste&lt;/attribute&gt;"
--       "      &lt;/item&gt;"
--       "    &lt;/submenu&gt;"
--       "  &lt;/menu&gt;"
--       "&lt;/interface&gt;",
--       -1);
--   
--   GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
--   gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
--   g_object_unref (builder);
--   
--   // ...
--   
--   GtkWidget *window = gtk_application_window_new (app);
--   </pre>
module GI.Gtk.Objects.ApplicationWindow

-- | Memory-managed wrapper type.
newtype ApplicationWindow
ApplicationWindow :: ManagedPtr ApplicationWindow -> ApplicationWindow

-- | Type class for types which can be safely cast to
--   <a>ApplicationWindow</a>, for instance with
--   <a>toApplicationWindow</a>.
class (GObject o, IsDescendantOf ApplicationWindow o) => IsApplicationWindow o

-- | Cast to <a>ApplicationWindow</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toApplicationWindow :: (MonadIO m, IsApplicationWindow o) => o -> m ApplicationWindow

-- | Gets the <tt>GtkShortcutsWindow</tt> that is associated with
--   <i><tt>window</tt></i>.
--   
--   See <a>applicationWindowSetHelpOverlay</a>.

-- | <i>Deprecated: (Since version 4.18)<tt>GtkShortcutsWindow</tt> will be
--   removed in GTK 5</i>
applicationWindowGetHelpOverlay :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m (Maybe ShortcutsWindow)

-- | Returns the unique ID of the window.
--   
--   If the window has not yet been added to a <tt>GtkApplication</tt>,
--   returns <tt>0</tt>.
applicationWindowGetId :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m Word32

-- | Returns whether the window will display a menubar for the app menu and
--   menubar as needed.
applicationWindowGetShowMenubar :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> m Bool

-- | Creates a new <tt>GtkApplicationWindow</tt>.
applicationWindowNew :: (HasCallStack, MonadIO m, IsApplication a) => a -> m ApplicationWindow

-- | Associates a shortcuts window with the application window.
--   
--   Additionally, sets up an action with the name
--   <tt>win.show-help-overlay</tt> to present it.
--   
--   The window takes responsibility for destroying the help overlay.

-- | <i>Deprecated: (Since version 4.18)<tt>GtkShortcutsWindow</tt> will be
--   removed in GTK 5</i>
applicationWindowSetHelpOverlay :: (HasCallStack, MonadIO m, IsApplicationWindow a, IsShortcutsWindow b) => a -> Maybe b -> m ()

-- | Sets whether the window will display a menubar for the app menu and
--   menubar as needed.
applicationWindowSetShowMenubar :: (HasCallStack, MonadIO m, IsApplicationWindow a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-menubar</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructApplicationWindowShowMenubar :: (IsApplicationWindow o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> applicationWindow #showMenubar
--   </pre>
getApplicationWindowShowMenubar :: (MonadIO m, IsApplicationWindow o) => o -> m Bool

-- | Set the value of the “<tt>show-menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> applicationWindow [ #showMenubar <a>:=</a> value ]
--   </pre>
setApplicationWindowShowMenubar :: (MonadIO m, IsApplicationWindow o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ApplicationWindow.ApplicationWindow
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ApplicationWindow.ApplicationWindow
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ApplicationWindow.ApplicationWindow
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ApplicationWindow.ApplicationWindow o) => GI.Gtk.Objects.ApplicationWindow.IsApplicationWindow o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ApplicationWindow.ApplicationWindow)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ApplicationWindow.ApplicationWindow
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ApplicationWindow.ApplicationWindow


-- | A high-level API for writing applications.
--   
--   <tt>GtkApplication</tt> supports many aspects of writing a GTK
--   application in a convenient fashion, without enforcing a
--   one-size-fits-all model.
--   
--   Currently, it handles GTK initialization, application uniqueness,
--   session management, provides some basic scriptability and desktop
--   shell integration by exporting actions and menus and manages a list of
--   toplevel windows whose life-cycle is automatically tied to the
--   life-cycle of your application.
--   
--   While <tt>GtkApplication</tt> works fine with plain <a>Window</a>s, it
--   is recommended to use it together with <a>ApplicationWindow</a>.
--   
--   <h2>Initialization</h2>
--   
--   A typical <tt>GtkApplication</tt> will create a window in its
--   <tt><i>GIO.Application::activate</i></tt>,
--   <tt><i>GIO.Application::open</i></tt> or
--   <tt><i>GIO.Application::command-line</i></tt> handlers. Note that all
--   of these signals may be emitted multiple times, so handlers must be
--   careful to take existing windows into account.
--   
--   A typical <a>activate</a> handler should look like this:
--   
--   <pre>
--   static void
--   activate (GApplication *gapp)
--   {
--     GtkApplication *app = GTK_APPLICATION (gapp);
--     GtkWindow *window;
--   
--     window = gtk_application_get_active_window (app);
--     if (!window)
--       window = create_window (app);
--   
--     gtk_window_present (window);
--   }
--   </pre>
--   
--   <h2>Automatic resources</h2>
--   
--   <tt>GtkApplication</tt> will automatically load menus from the
--   <tt>GtkBuilder</tt> resource located at "gtk/menus.ui", relative to
--   the application's resource base path (see
--   <a>applicationSetResourceBasePath</a>). The menu with the ID "menubar"
--   is taken as the application's menubar. Additional menus (most
--   interesting submenus) can be named and accessed via
--   <a>applicationGetMenuById</a> which allows for dynamic population of a
--   part of the menu structure.
--   
--   Note that automatic resource loading uses the resource base path that
--   is set at construction time and will not work if the resource base
--   path is changed at a later time.
--   
--   It is also possible to provide the menubar manually using
--   <a>applicationSetMenubar</a>.
--   
--   <tt>GtkApplication</tt> will also automatically setup an icon search
--   path for the default icon theme by appending "icons" to the resource
--   base path. This allows your application to easily store its icons as
--   resources. See <a>iconThemeAddResourcePath</a> for more information.
--   
--   If there is a resource located at <tt>gtk/help-overlay.ui</tt> which
--   defines a <a>ShortcutsWindow</a> with ID <tt>help_overlay</tt> then
--   <tt>GtkApplication</tt> associates an instance of this shortcuts
--   window with each <a>ApplicationWindow</a> and sets up the keyboard
--   accelerator &lt;kbd&gt;Control&lt;/kbd&gt;+&lt;kbd&gt;?&lt;/kbd&gt; to
--   open it. To create a menu item that displays the shortcuts window,
--   associate the item with the action <tt>win.show-help-overlay</tt>.
--   
--   <tt>GtkApplication</tt> will also automatically set the application id
--   as the default window icon. Use <a>windowSetDefaultIconName</a> or
--   <a>Window:iconName</a> to override that behavior.
--   
--   <h1>Inhibiting</h1>
--   
--   An application can block various ways to end the session with the
--   <a>applicationInhibit</a> function. Typical use cases for this kind of
--   inhibiting are long-running, uninterruptible operations, such as
--   burning a CD or performing a disk backup. The session manager may not
--   honor the inhibitor, but it can be expected to inform the user about
--   the negative consequences of ending the session while inhibitors are
--   present.
--   
--   <h2>A simple application</h2>
--   
--   <a>A simple example</a> is available in the GTK source code repository
--   
--   <h2>See Also</h2>
--   
--   <ul>
--   <li><a>Using GtkApplication</a></li>
--   <li><a>Getting Started with GTK: Basics</a></li>
--   </ul>
module GI.Gtk.Objects.Application

-- | Memory-managed wrapper type.
newtype Application
Application :: ManagedPtr Application -> Application

-- | Type class for types which can be safely cast to <a>Application</a>,
--   for instance with <a>toApplication</a>.
class (GObject o, IsDescendantOf Application o) => IsApplication o

-- | Cast to <a>Application</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toApplication :: (MonadIO m, IsApplication o) => o -> m Application

-- | Adds a window to the application.
--   
--   This call can only happen after the application has started;
--   typically, you should add new application windows in response to the
--   emission of the <tt><i>GIO.Application::activate</i></tt> signal.
--   
--   This call is equivalent to setting the <a>Window:application</a>
--   property of the window to <i><tt>application</tt></i>.
--   
--   Normally, the connection between the application and the window will
--   remain until the window is destroyed, but you can explicitly remove it
--   with <a>applicationRemoveWindow</a>.
--   
--   GTK will keep the application running as long as it has any windows.
applicationAddWindow :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> b -> m ()

-- | Gets the accelerators that are currently associated with the given
--   action.
applicationGetAccelsForAction :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m [Text]

-- | Returns the list of actions (possibly empty) that the accelerator maps
--   to.
--   
--   Each item in the list is a detailed action name in the usual form.
--   
--   This might be useful to discover if an accel already exists in order
--   to prevent installation of a conflicting accelerator (from an
--   accelerator editor or a plugin system, for example). Note that having
--   more than one action per accelerator may not be a bad thing and might
--   make sense in cases where the actions never appear in the same
--   context.
--   
--   In case there are no actions for a given accelerator, an empty array
--   is returned. <tt>NULL</tt> is never returned.
--   
--   It is a programmer error to pass an invalid accelerator string.
--   
--   If you are unsure, check it with <a>acceleratorParse</a> first.
applicationGetActionsForAccel :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m [Text]

-- | Gets the “active” window for the application.
--   
--   The active window is the one that was most recently focused (within
--   the application). This window may not have the focus at the moment if
--   another application has it — this is just the most recently-focused
--   window within this application.
applicationGetActiveWindow :: (HasCallStack, MonadIO m, IsApplication a) => a -> m (Maybe Window)

-- | Gets a menu from automatically loaded resources.
--   
--   See <a>the section on Automatic resources</a> for more information.
applicationGetMenuById :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> m (Maybe Menu)

-- | Returns the menu model for the menu bar of the application.
applicationGetMenubar :: (HasCallStack, MonadIO m, IsApplication a) => a -> m (Maybe MenuModel)

-- | Returns the window with the given ID.
--   
--   The ID of a <tt>GtkApplicationWindow</tt> can be retrieved with
--   <a>applicationWindowGetId</a>.
applicationGetWindowById :: (HasCallStack, MonadIO m, IsApplication a) => a -> Word32 -> m (Maybe Window)

-- | Gets a list of the window associated with the application.
--   
--   The list is sorted by most recently focused window, such that the
--   first element is the currently focused window. (Useful for choosing a
--   parent for a transient window.)
--   
--   The list that is returned should not be modified in any way. It will
--   only remain valid until the next focus change or window creation or
--   deletion.
applicationGetWindows :: (HasCallStack, MonadIO m, IsApplication a) => a -> m [Window]

-- | Informs the session manager that certain types of actions should be
--   inhibited.
--   
--   This is not guaranteed to work on all platforms and for all types of
--   actions.
--   
--   Applications should invoke this method when they begin an operation
--   that should not be interrupted, such as creating a CD or DVD. The
--   types of actions that may be blocked are specified by the
--   <i><tt>flags</tt></i> parameter. When the application completes the
--   operation it should call <a>applicationUninhibit</a> to remove the
--   inhibitor. Note that an application can have multiple inhibitors, and
--   all of them must be individually removed. Inhibitors are also cleared
--   when the application exits.
--   
--   Applications should not expect that they will always be able to block
--   the action. In most cases, users will be given the option to force the
--   action to take place.
--   
--   The <i><tt>reason</tt></i> message should be short and to the point.
--   
--   If a window is given, the session manager may point the user to this
--   window to find out more about why the action is inhibited.
--   
--   The cookie that is returned by this function should be used as an
--   argument to <a>applicationUninhibit</a> in order to remove the
--   request.
applicationInhibit :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> Maybe b -> [ApplicationInhibitFlags] -> Maybe Text -> m Word32

-- | Lists the detailed action names which have associated accelerators.
--   
--   See <a>applicationSetAccelsForAction</a>.
applicationListActionDescriptions :: (HasCallStack, MonadIO m, IsApplication a) => a -> m [Text]

-- | Creates a new application instance.
--   
--   When using <tt>GtkApplication</tt>, it is not necessary to call
--   <a>init</a> manually. It is called as soon as the application gets
--   registered as the primary instance.
--   
--   Concretely, <a>init</a> is called in the default handler for the
--   <tt>GApplication::startup</tt> signal. Therefore,
--   <tt>GtkApplication</tt> subclasses should always chain up in their
--   <tt><i>GIO.Application.startup()</i></tt> handler before using any GTK
--   API.
--   
--   Note that commandline arguments are not passed to <a>init</a>.
--   
--   If <tt>application_id</tt> is not <tt>NULL</tt>, then it must be
--   valid. See <a>applicationIdIsValid</a>.
--   
--   If no application ID is given then some features (most notably
--   application uniqueness) will be disabled.
applicationNew :: (HasCallStack, MonadIO m) => Maybe Text -> [ApplicationFlags] -> m Application

-- | Remove a window from the application.
--   
--   If the window belongs to the application then this call is equivalent
--   to setting the <a>Window:application</a> property of the window to
--   <tt>NULL</tt>.
--   
--   The application may stop running as a result of a call to this
--   function, if the window was the last window of the application.
applicationRemoveWindow :: (HasCallStack, MonadIO m, IsApplication a, IsWindow b) => a -> b -> m ()

-- | Sets zero or more keyboard accelerators that will trigger the given
--   action.
--   
--   The first item in <i><tt>accels</tt></i> will be the primary
--   accelerator, which may be displayed in the UI.
--   
--   To remove all accelerators for an action, use an empty,
--   zero-terminated array for <i><tt>accels</tt></i>.
--   
--   For the <i><tt>detailedActionName</tt></i>, see
--   <a>actionParseDetailedName</a> and [Gio.Action.print_detailed_name].
applicationSetAccelsForAction :: (HasCallStack, MonadIO m, IsApplication a) => a -> Text -> [Text] -> m ()

-- | Sets or unsets the menubar for windows of the application.
--   
--   This is a menubar in the traditional sense.
--   
--   This can only be done in the primary instance of the application,
--   after it has been registered.
--   <tt><i>GIO.Application.startup()</i></tt> is a good place to call
--   this.
--   
--   Depending on the desktop environment, this may appear at the top of
--   each window, or at the top of the screen. In some environments, if
--   both the application menu and the menubar are set, the application
--   menu will be presented as if it were the first item of the menubar.
--   Other environments treat the two as completely separate — for example,
--   the application menu may be rendered by the desktop shell while the
--   menubar (if set) remains in each individual window.
--   
--   Use the base <tt>GActionMap</tt> interface to add actions, to respond
--   to the user selecting these menu items.
applicationSetMenubar :: (HasCallStack, MonadIO m, IsApplication a, IsMenuModel b) => a -> Maybe b -> m ()

-- | Removes an inhibitor that has been previously established.
--   
--   See <a>applicationInhibit</a>.
--   
--   Inhibitors are also cleared when the application exits.
applicationUninhibit :: (HasCallStack, MonadIO m, IsApplication a) => a -> Word32 -> m ()

-- | Get the value of the “<tt>active-window</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #activeWindow
--   </pre>
getApplicationActiveWindow :: (MonadIO m, IsApplication o) => o -> m (Maybe Window)

-- | Set the value of the “<tt>menubar</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #menubar
--   </pre>
clearApplicationMenubar :: (MonadIO m, IsApplication o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>menubar</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructApplicationMenubar :: (IsApplication o, MonadIO m, IsMenuModel a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #menubar
--   </pre>
getApplicationMenubar :: (MonadIO m, IsApplication o) => o -> m (Maybe MenuModel)

-- | Set the value of the “<tt>menubar</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> application [ #menubar <a>:=</a> value ]
--   </pre>
setApplicationMenubar :: (MonadIO m, IsApplication o, IsMenuModel a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>register-session</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructApplicationRegisterSession :: (IsApplication o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>register-session</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #registerSession
--   </pre>
getApplicationRegisterSession :: (MonadIO m, IsApplication o) => o -> m Bool

-- | Set the value of the “<tt>register-session</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> application [ #registerSession <a>:=</a> value ]
--   </pre>
setApplicationRegisterSession :: (MonadIO m, IsApplication o) => o -> Bool -> m ()

-- | Get the value of the “<tt>screensaver-active</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> application #screensaverActive
--   </pre>
getApplicationScreensaverActive :: (MonadIO m, IsApplication o) => o -> m Bool

-- | Emitted when the session manager is about to end the session.
--   
--   Applications can connect to this signal and call
--   <a>applicationInhibit</a> with
--   [flags<i><tt>gtk</tt></i>.ApplicationInhibitFlags.logout] to delay the
--   end of the session until state has been saved.
type ApplicationQueryEndCallback = IO ()

-- | Connect a signal handler for the <a>queryEnd</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> application #queryEnd callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterApplicationQueryEnd :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationQueryEndCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>queryEnd</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> application #queryEnd callback
--   </pre>
onApplicationQueryEnd :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationQueryEndCallback) -> m SignalHandlerId

-- | Emitted when a window is added to an application.
--   
--   See <a>applicationAddWindow</a>.
type ApplicationWindowAddedCallback = Window -> IO ()

-- | Connect a signal handler for the <a>windowAdded</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> application #windowAdded callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterApplicationWindowAdded :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowAddedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowAdded</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> application #windowAdded callback
--   </pre>
onApplicationWindowAdded :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowAddedCallback) -> m SignalHandlerId

-- | Emitted when a window is removed from an application.
--   
--   This can happen as a side-effect of the window being destroyed or
--   explicitly through <a>applicationRemoveWindow</a>.
type ApplicationWindowRemovedCallback = Window -> IO ()

-- | Connect a signal handler for the <a>windowRemoved</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> application #windowRemoved callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterApplicationWindowRemoved :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowRemovedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>windowRemoved</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> application #windowRemoved callback
--   </pre>
onApplicationWindowRemoved :: (IsApplication a, MonadIO m) => a -> ((?self :: a) => ApplicationWindowRemovedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.Application.Application
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.Application.Application
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.Application.Application
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.Application.Application o) => GI.Gtk.Objects.Application.IsApplication o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.Application.Application)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.Application.Application
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.Application.Application


-- | <tt>GtkAppChooserWidget</tt> is a widget for selecting applications.
--   
--   It is the main building block for <a>AppChooserDialog</a>. Most
--   applications only need to use the latter; but you can use this widget
--   as part of a larger widget if you have special needs.
--   
--   <tt>GtkAppChooserWidget</tt> offers detailed control over what
--   applications are shown, using the <a>AppChooserWidget:showDefault</a>,
--   <a>AppChooserWidget:showRecommended</a>,
--   <a>AppChooserWidget:showFallback</a>,
--   <a>AppChooserWidget:showOther</a> and <a>AppChooserWidget:showAll</a>
--   properties. See the <a>AppChooser</a> documentation for more
--   information about these groups of applications.
--   
--   To keep track of the selected application, use the
--   <a>AppChooserWidget::applicationSelected</a> and
--   <a>AppChooserWidget::applicationActivated</a> signals.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkAppChooserWidget</tt> has a single CSS node with name
--   appchooser.
module GI.Gtk.Objects.AppChooserWidget

-- | Memory-managed wrapper type.
newtype AppChooserWidget
AppChooserWidget :: ManagedPtr AppChooserWidget -> AppChooserWidget

-- | Type class for types which can be safely cast to
--   <a>AppChooserWidget</a>, for instance with <a>toAppChooserWidget</a>.
class (GObject o, IsDescendantOf AppChooserWidget o) => IsAppChooserWidget o

-- | Cast to <a>AppChooserWidget</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toAppChooserWidget :: (MonadIO m, IsAppChooserWidget o) => o -> m AppChooserWidget

-- | Returns the text that is shown if there are not applications that can
--   handle the content type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetGetDefaultText :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m (Maybe Text)

-- | Gets whether the app chooser should show all applications in a flat
--   list.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetGetShowAll :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Gets whether the app chooser should show the default handler for the
--   content type in a separate section.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetGetShowDefault :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Gets whether the app chooser should show related applications for the
--   content type in a separate section.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetGetShowFallback :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Gets whether the app chooser should show applications which are
--   unrelated to the content type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetGetShowOther :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Gets whether the app chooser should show recommended applications for
--   the content type in a separate section.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetGetShowRecommended :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> m Bool

-- | Creates a new <tt>GtkAppChooserWidget</tt> for applications that can
--   handle content of the given type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetNew :: (HasCallStack, MonadIO m) => Text -> m AppChooserWidget

-- | Sets the text that is shown if there are not applications that can
--   handle the content type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetSetDefaultText :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Text -> m ()

-- | Sets whether the app chooser should show all applications in a flat
--   list.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetSetShowAll :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show the default handler for the
--   content type in a separate section.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetSetShowDefault :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show related applications for the
--   content type in a separate section.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetSetShowFallback :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show applications which are
--   unrelated to the content type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetSetShowOther :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Sets whether the app chooser should show recommended applications for
--   the content type in a separate section.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserWidgetSetShowRecommended :: (HasCallStack, MonadIO m, IsAppChooserWidget a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserWidgetDefaultText :: (IsAppChooserWidget o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #defaultText
--   </pre>
getAppChooserWidgetDefaultText :: (MonadIO m, IsAppChooserWidget o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>default-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #defaultText <a>:=</a> value ]
--   </pre>
setAppChooserWidgetDefaultText :: (MonadIO m, IsAppChooserWidget o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-all</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAppChooserWidgetShowAll :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showAll
--   </pre>
getAppChooserWidgetShowAll :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-all</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showAll <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowAll :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-default</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserWidgetShowDefault :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showDefault
--   </pre>
getAppChooserWidgetShowDefault :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-default</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showDefault <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowDefault :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-fallback</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserWidgetShowFallback :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showFallback
--   </pre>
getAppChooserWidgetShowFallback :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-fallback</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showFallback <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowFallback :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-other</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAppChooserWidgetShowOther :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-other</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showOther
--   </pre>
getAppChooserWidgetShowOther :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-other</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showOther <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowOther :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-recommended</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAppChooserWidgetShowRecommended :: (IsAppChooserWidget o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-recommended</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserWidget #showRecommended
--   </pre>
getAppChooserWidgetShowRecommended :: (MonadIO m, IsAppChooserWidget o) => o -> m Bool

-- | Set the value of the “<tt>show-recommended</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserWidget [ #showRecommended <a>:=</a> value ]
--   </pre>
setAppChooserWidgetShowRecommended :: (MonadIO m, IsAppChooserWidget o) => o -> Bool -> m ()

-- | Emitted when an application item is activated from the widget's list.
--   
--   This usually happens when the user double clicks an item, or an item
--   is selected and the user presses one of the keys Space, Shift+Space,
--   Return or Enter.
type AppChooserWidgetApplicationActivatedCallback = AppInfo -> IO ()

-- | Connect a signal handler for the <a>applicationActivated</a> signal,
--   to be run after the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>after</a> appChooserWidget #applicationActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserWidgetApplicationActivated :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applicationActivated</a> signal,
--   to be run before the default handler. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserWidget #applicationActivated callback
--   </pre>
onAppChooserWidgetApplicationActivated :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationActivatedCallback) -> m SignalHandlerId

-- | Emitted when an application item is selected from the widget's list.
type AppChooserWidgetApplicationSelectedCallback = AppInfo -> IO ()

-- | Connect a signal handler for the <a>applicationSelected</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> appChooserWidget #applicationSelected callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserWidgetApplicationSelected :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationSelectedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>applicationSelected</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserWidget #applicationSelected callback
--   </pre>
onAppChooserWidgetApplicationSelected :: (IsAppChooserWidget a, MonadIO m) => a -> ((?self :: a) => AppChooserWidgetApplicationSelectedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.AppChooserWidget.AppChooserWidget
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AppChooserWidget.AppChooserWidget
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AppChooserWidget.AppChooserWidget
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AppChooserWidget.AppChooserWidget o) => GI.Gtk.Objects.AppChooserWidget.IsAppChooserWidget o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AppChooserWidget.AppChooserWidget)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AppChooserWidget.AppChooserWidget
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AppChooserWidget.AppChooserWidget


-- | <tt>GtkAppChooserDialog</tt> shows a <tt>GtkAppChooserWidget</tt>
--   inside a <tt>GtkDialog</tt>.
--   
--   &lt;picture&gt; &lt;source srcset="appchooserdialog-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkAppChooserDialog" src="appchooserdialog.png"&gt; &lt;/picture&gt;
--   
--   Note that <tt>GtkAppChooserDialog</tt> does not have any interesting
--   methods of its own. Instead, you should get the embedded
--   <tt>GtkAppChooserWidget</tt> using <a>appChooserDialogGetWidget</a>
--   and call its methods if the generic <a>AppChooser</a> interface is not
--   sufficient for your needs.
--   
--   To set the heading that is shown above the
--   <tt>GtkAppChooserWidget</tt>, use <a>appChooserDialogSetHeading</a>.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkAppChooserDialog</tt> has a single CSS node with the name
--   <tt>window</tt> and style class <tt>.appchooser</tt>.
module GI.Gtk.Objects.AppChooserDialog

-- | Memory-managed wrapper type.
newtype AppChooserDialog
AppChooserDialog :: ManagedPtr AppChooserDialog -> AppChooserDialog

-- | Type class for types which can be safely cast to
--   <a>AppChooserDialog</a>, for instance with <a>toAppChooserDialog</a>.
class (GObject o, IsDescendantOf AppChooserDialog o) => IsAppChooserDialog o

-- | Cast to <a>AppChooserDialog</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toAppChooserDialog :: (MonadIO m, IsAppChooserDialog o) => o -> m AppChooserDialog

-- | Returns the text to display at the top of the dialog.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserDialogGetHeading :: (HasCallStack, MonadIO m, IsAppChooserDialog a) => a -> m (Maybe Text)

-- | Returns the <tt>GtkAppChooserWidget</tt> of this dialog.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserDialogGetWidget :: (HasCallStack, MonadIO m, IsAppChooserDialog a) => a -> m Widget

-- | Creates a new <tt>GtkAppChooserDialog</tt> for the provided
--   <tt>GFile</tt>.
--   
--   The dialog will show applications that can open the file.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserDialogNew :: (HasCallStack, MonadIO m, IsWindow a, IsFile b) => Maybe a -> [DialogFlags] -> b -> m AppChooserDialog

-- | Creates a new <tt>GtkAppChooserDialog</tt> for the provided content
--   type.
--   
--   The dialog will show applications that can open the content type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserDialogNewForContentType :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> [DialogFlags] -> Text -> m AppChooserDialog

-- | Sets the text to display at the top of the dialog.
--   
--   If the heading is not set, the dialog displays a default text.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserDialogSetHeading :: (HasCallStack, MonadIO m, IsAppChooserDialog a) => a -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>gfile</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAppChooserDialogGfile :: (IsAppChooserDialog o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>gfile</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserDialog #gfile
--   </pre>
getAppChooserDialogGfile :: (MonadIO m, IsAppChooserDialog o) => o -> m (Maybe File)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>heading</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAppChooserDialogHeading :: (IsAppChooserDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserDialog #heading
--   </pre>
getAppChooserDialogHeading :: (MonadIO m, IsAppChooserDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserDialog [ #heading <a>:=</a> value ]
--   </pre>
setAppChooserDialogHeading :: (MonadIO m, IsAppChooserDialog o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.AppChooserDialog.AppChooserDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AppChooserDialog.AppChooserDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AppChooserDialog.AppChooserDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AppChooserDialog.AppChooserDialog o) => GI.Gtk.Objects.AppChooserDialog.IsAppChooserDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AppChooserDialog.AppChooserDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AppChooserDialog.AppChooserDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AppChooserDialog.AppChooserDialog


-- | The <tt>GtkAppChooserButton</tt> lets the user select an application.
--   
--   &lt;picture&gt; &lt;source srcset="appchooserbutton-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkAppChooserButton" src="appchooserbutton.png"&gt; &lt;/picture&gt;
--   
--   Initially, a <tt>GtkAppChooserButton</tt> selects the first
--   application in its list, which will either be the most-recently used
--   application or, if <a>AppChooserButton:showDefaultItem</a> is
--   <a>True</a>, the default application.
--   
--   The list of applications shown in a <tt>GtkAppChooserButton</tt>
--   includes the recommended applications for the given content type. When
--   <a>AppChooserButton:showDefaultItem</a> is set, the default
--   application is also included. To let the user chooser other
--   applications, you can set the <a>AppChooserButton:showDialogItem</a>
--   property, which allows to open a full <a>AppChooserDialog</a>.
--   
--   It is possible to add custom items to the list, using
--   <a>appChooserButtonAppendCustomItem</a>. These items cause the
--   <a>AppChooserButton::customItemActivated</a> signal to be emitted when
--   they are selected.
--   
--   To track changes in the selected application, use the
--   <a>AppChooserButton::changed</a> signal.
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkAppChooserButton</tt> has a single CSS node with the name
--   “appchooserbutton”.
module GI.Gtk.Objects.AppChooserButton

-- | Memory-managed wrapper type.
newtype AppChooserButton
AppChooserButton :: ManagedPtr AppChooserButton -> AppChooserButton

-- | Type class for types which can be safely cast to
--   <a>AppChooserButton</a>, for instance with <a>toAppChooserButton</a>.
class (GObject o, IsDescendantOf AppChooserButton o) => IsAppChooserButton o

-- | Cast to <a>AppChooserButton</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toAppChooserButton :: (MonadIO m, IsAppChooserButton o) => o -> m AppChooserButton

-- | Appends a custom item to the list of applications that is shown in the
--   popup.
--   
--   The item name must be unique per-widget. Clients can use the provided
--   name as a detail for the <a>AppChooserButton::customItemActivated</a>
--   signal, to add a callback for the activation of a particular custom
--   item in the list.
--   
--   See also <a>appChooserButtonAppendSeparator</a>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonAppendCustomItem :: (HasCallStack, MonadIO m, IsAppChooserButton a, IsIcon b) => a -> Text -> Text -> b -> m ()

-- | Appends a separator to the list of applications that is shown in the
--   popup.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonAppendSeparator :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m ()

-- | Returns the text to display at the top of the dialog.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonGetHeading :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m (Maybe Text)

-- | Gets whether the dialog is modal.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonGetModal :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m Bool

-- | Returns whether the dropdown menu should show the default application
--   at the top.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonGetShowDefaultItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m Bool

-- | Returns whether the dropdown menu shows an item for a
--   <tt>GtkAppChooserDialog</tt>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonGetShowDialogItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> m Bool

-- | Creates a new <tt>GtkAppChooserButton</tt> for applications that can
--   handle content of the given type.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonNew :: (HasCallStack, MonadIO m) => Text -> m AppChooserButton

-- | Selects a custom item.
--   
--   See <a>appChooserButtonAppendCustomItem</a>.
--   
--   Use <a>appChooserRefresh</a> to bring the selection to its initial
--   state.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonSetActiveCustomItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Text -> m ()

-- | Sets the text to display at the top of the dialog.
--   
--   If the heading is not set, the dialog displays a default text.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonSetHeading :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Text -> m ()

-- | Sets whether the dialog should be modal.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonSetModal :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Bool -> m ()

-- | Sets whether the dropdown menu of this button should show the default
--   application for the given content type at top.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonSetShowDefaultItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Bool -> m ()

-- | Sets whether the dropdown menu of this button should show an entry to
--   trigger a <tt>GtkAppChooserDialog</tt>.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserButtonSetShowDialogItem :: (HasCallStack, MonadIO m, IsAppChooserButton a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>heading</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAppChooserButtonHeading :: (IsAppChooserButton o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserButton #heading
--   </pre>
getAppChooserButtonHeading :: (MonadIO m, IsAppChooserButton o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>heading</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserButton [ #heading <a>:=</a> value ]
--   </pre>
setAppChooserButtonHeading :: (MonadIO m, IsAppChooserButton o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAppChooserButtonModal :: (IsAppChooserButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserButton #modal
--   </pre>
getAppChooserButtonModal :: (MonadIO m, IsAppChooserButton o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserButton [ #modal <a>:=</a> value ]
--   </pre>
setAppChooserButtonModal :: (MonadIO m, IsAppChooserButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-default-item</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAppChooserButtonShowDefaultItem :: (IsAppChooserButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-default-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserButton #showDefaultItem
--   </pre>
getAppChooserButtonShowDefaultItem :: (MonadIO m, IsAppChooserButton o) => o -> m Bool

-- | Set the value of the “<tt>show-default-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserButton [ #showDefaultItem <a>:=</a> value ]
--   </pre>
setAppChooserButtonShowDefaultItem :: (MonadIO m, IsAppChooserButton o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-dialog-item</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAppChooserButtonShowDialogItem :: (IsAppChooserButton o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-dialog-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooserButton #showDialogItem
--   </pre>
getAppChooserButtonShowDialogItem :: (MonadIO m, IsAppChooserButton o) => o -> m Bool

-- | Set the value of the “<tt>show-dialog-item</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> appChooserButton [ #showDialogItem <a>:=</a> value ]
--   </pre>
setAppChooserButtonShowDialogItem :: (MonadIO m, IsAppChooserButton o) => o -> Bool -> m ()

-- | Emitted to when the button is activated.
--   
--   The <tt>::activate</tt> signal on <tt>GtkAppChooserButton</tt> is an
--   action signal and emitting it causes the button to pop up its dialog.
--   
--   <i>Since: 4.4</i>
type AppChooserButtonActivateCallback = IO ()

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> appChooserButton #activate callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserButtonActivate :: (IsAppChooserButton a, MonadIO m) => a -> ((?self :: a) => AppChooserButtonActivateCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activate</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserButton #activate callback
--   </pre>
onAppChooserButtonActivate :: (IsAppChooserButton a, MonadIO m) => a -> ((?self :: a) => AppChooserButtonActivateCallback) -> m SignalHandlerId

-- | Emitted when the active application changes.
type AppChooserButtonChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> appChooserButton #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserButtonChanged :: (IsAppChooserButton a, MonadIO m) => a -> ((?self :: a) => AppChooserButtonChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserButton #changed callback
--   </pre>
onAppChooserButtonChanged :: (IsAppChooserButton a, MonadIO m) => a -> ((?self :: a) => AppChooserButtonChangedCallback) -> m SignalHandlerId

-- | Emitted when a custom item is activated.
--   
--   Use <a>appChooserButtonAppendCustomItem</a>, to add custom items.
type AppChooserButtonCustomItemActivatedCallback = Text -> IO ()

-- | Connect a signal handler for the <a>customItemActivated</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> appChooserButton #customItemActivated callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to
--   “<tt>custom-item-activated::detail</tt>” instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAppChooserButtonCustomItemActivated :: (IsAppChooserButton a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AppChooserButtonCustomItemActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>customItemActivated</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> appChooserButton #customItemActivated callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to
--   “<tt>custom-item-activated::detail</tt>” instead.
onAppChooserButtonCustomItemActivated :: (IsAppChooserButton a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => AppChooserButtonCustomItemActivatedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.AppChooserButton.AppChooserButton
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AppChooserButton.AppChooserButton
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AppChooserButton.AppChooserButton
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AppChooserButton.AppChooserButton o) => GI.Gtk.Objects.AppChooserButton.IsAppChooserButton o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AppChooserButton.AppChooserButton)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AppChooserButton.AppChooserButton
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AppChooserButton.AppChooserButton


-- | Collects the arguments that are needed to present a message to the
--   user.
--   
--   The message is shown with the <a>alertDialogChoose</a> function.
--   
--   If you don't need to wait for a button to be clicked, you can use
--   <a>alertDialogShow</a>.
--   
--   <i>Since: 4.10</i>
module GI.Gtk.Objects.AlertDialog

-- | Memory-managed wrapper type.
newtype AlertDialog
AlertDialog :: ManagedPtr AlertDialog -> AlertDialog

-- | Type class for types which can be safely cast to <a>AlertDialog</a>,
--   for instance with <a>toAlertDialog</a>.
class (GObject o, IsDescendantOf AlertDialog o) => IsAlertDialog o

-- | Cast to <a>AlertDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAlertDialog :: (MonadIO m, IsAlertDialog o) => o -> m AlertDialog

-- | Shows the alert to the user.
--   
--   It is ok to pass <tt>NULL</tt> for the callback if the alert does not
--   have more than one button. A simpler API for this case is
--   <a>alertDialogShow</a>.
--   
--   <i>Since: 4.10</i>
alertDialogChoose :: (HasCallStack, MonadIO m, IsAlertDialog a, IsWindow b, IsCancellable c) => a -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>alertDialogChoose</a> call.
--   
--   <i>Since: 4.10</i>
alertDialogChooseFinish :: (HasCallStack, MonadIO m, IsAlertDialog a, IsAsyncResult b) => a -> b -> m Int32

-- | Returns the button labels for the alert.
--   
--   <i>Since: 4.10</i>
alertDialogGetButtons :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> m (Maybe [Text])

-- | Returns the index of the cancel button.
--   
--   <i>Since: 4.10</i>
alertDialogGetCancelButton :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> m Int32

-- | Returns the index of the default button.
--   
--   <i>Since: 4.10</i>
alertDialogGetDefaultButton :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> m Int32

-- | Returns the detail text that will be shown in the alert.
--   
--   <i>Since: 4.10</i>
alertDialogGetDetail :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> m Text

-- | Returns the message that will be shown in the alert.
--   
--   <i>Since: 4.10</i>
alertDialogGetMessage :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> m Text

-- | Returns whether the alert blocks interaction with the parent window
--   while it is presented.
--   
--   <i>Since: 4.10</i>
alertDialogGetModal :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> m Bool

-- | Sets the button labels for the alert.
--   
--   <i>Since: 4.10</i>
alertDialogSetButtons :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> [Text] -> m ()

-- | Sets the index of the cancel button.
--   
--   See <a>AlertDialog:cancelButton</a> for details of how this value is
--   used.
--   
--   <i>Since: 4.10</i>
alertDialogSetCancelButton :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> Int32 -> m ()

-- | Sets the index of the default button.
--   
--   See <a>AlertDialog:defaultButton</a> for details of how this value is
--   used.
--   
--   <i>Since: 4.10</i>
alertDialogSetDefaultButton :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> Int32 -> m ()

-- | Sets the detail text that will be shown in the alert.
--   
--   <i>Since: 4.10</i>
alertDialogSetDetail :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> Text -> m ()

-- | Sets the message that will be shown in the alert.
--   
--   <i>Since: 4.10</i>
alertDialogSetMessage :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> Text -> m ()

-- | Sets whether the alert blocks interaction with the parent window while
--   it is presented.
--   
--   <i>Since: 4.10</i>
alertDialogSetModal :: (HasCallStack, MonadIO m, IsAlertDialog a) => a -> Bool -> m ()

-- | Shows the alert to the user.
--   
--   This function is a simpler version of <a>alertDialogChoose</a>
--   intended for dialogs with a single button.
--   
--   If you want to cancel the dialog or if the alert has more than one
--   button, you should use that function instead and provide it with a
--   <a>Cancellable</a> and callback respectively.
--   
--   <i>Since: 4.10</i>
alertDialogShow :: (HasCallStack, MonadIO m, IsAlertDialog a, IsWindow b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>buttons</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlertDialogButtons :: (IsAlertDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>buttons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alertDialog #buttons
--   </pre>
getAlertDialogButtons :: (MonadIO m, IsAlertDialog o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>buttons</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alertDialog [ #buttons <a>:=</a> value ]
--   </pre>
setAlertDialogButtons :: (MonadIO m, IsAlertDialog o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>cancel-button</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAlertDialogCancelButton :: (IsAlertDialog o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>cancel-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alertDialog #cancelButton
--   </pre>
getAlertDialogCancelButton :: (MonadIO m, IsAlertDialog o) => o -> m Int32

-- | Set the value of the “<tt>cancel-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alertDialog [ #cancelButton <a>:=</a> value ]
--   </pre>
setAlertDialogCancelButton :: (MonadIO m, IsAlertDialog o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>default-button</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAlertDialogDefaultButton :: (IsAlertDialog o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>default-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alertDialog #defaultButton
--   </pre>
getAlertDialogDefaultButton :: (MonadIO m, IsAlertDialog o) => o -> m Int32

-- | Set the value of the “<tt>default-button</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alertDialog [ #defaultButton <a>:=</a> value ]
--   </pre>
setAlertDialogDefaultButton :: (MonadIO m, IsAlertDialog o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>detail</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlertDialogDetail :: (IsAlertDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>detail</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alertDialog #detail
--   </pre>
getAlertDialogDetail :: (MonadIO m, IsAlertDialog o) => o -> m Text

-- | Set the value of the “<tt>detail</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alertDialog [ #detail <a>:=</a> value ]
--   </pre>
setAlertDialogDetail :: (MonadIO m, IsAlertDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>message</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlertDialogMessage :: (IsAlertDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>message</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alertDialog #message
--   </pre>
getAlertDialogMessage :: (MonadIO m, IsAlertDialog o) => o -> m Text

-- | Set the value of the “<tt>message</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alertDialog [ #message <a>:=</a> value ]
--   </pre>
setAlertDialogMessage :: (MonadIO m, IsAlertDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>modal</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAlertDialogModal :: (IsAlertDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> alertDialog #modal
--   </pre>
getAlertDialogModal :: (MonadIO m, IsAlertDialog o) => o -> m Bool

-- | Set the value of the “<tt>modal</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> alertDialog [ #modal <a>:=</a> value ]
--   </pre>
setAlertDialogModal :: (MonadIO m, IsAlertDialog o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.AlertDialog.AlertDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AlertDialog.AlertDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AlertDialog.AlertDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AlertDialog.AlertDialog o) => GI.Gtk.Objects.AlertDialog.IsAlertDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AlertDialog.AlertDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AlertDialog.AlertDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AlertDialog.AlertDialog


-- | Activates a widget.
--   
--   Widgets are activated by calling <a>widgetActivate</a>.
module GI.Gtk.Objects.ActivateAction

-- | Memory-managed wrapper type.
newtype ActivateAction
ActivateAction :: ManagedPtr ActivateAction -> ActivateAction

-- | Type class for types which can be safely cast to
--   <a>ActivateAction</a>, for instance with <a>toActivateAction</a>.
class (GObject o, IsDescendantOf ActivateAction o) => IsActivateAction o

-- | Cast to <a>ActivateAction</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toActivateAction :: (MonadIO m, IsActivateAction o) => o -> m ActivateAction

-- | Gets the activate action.
--   
--   This is an action that calls <a>widgetActivate</a> on the given widget
--   upon activation.
activateActionGet :: (HasCallStack, MonadIO m) => m ActivateAction
instance GHC.Classes.Eq GI.Gtk.Objects.ActivateAction.ActivateAction
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ActivateAction.ActivateAction
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ActivateAction.ActivateAction
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ActivateAction.ActivateAction o) => GI.Gtk.Objects.ActivateAction.IsActivateAction o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ActivateAction.ActivateAction)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ActivateAction.ActivateAction
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ActivateAction.ActivateAction


-- | Presents contextual actions.
--   
--   &lt;picture&gt; &lt;source srcset="action-bar-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkActionBar" src="action-bar.png"&gt; &lt;/picture&gt;
--   
--   <tt>GtkActionBar</tt> is expected to be displayed below the content
--   and expand horizontally to fill the area.
--   
--   It allows placing children at the start or the end. In addition, it
--   contains an internal centered box which is centered with respect to
--   the full width of the box, even if the children at either side take up
--   different amounts of space.
--   
--   <h1>GtkActionBar as GtkBuildable</h1>
--   
--   The <tt>GtkActionBar</tt> implementation of the <tt>GtkBuildable</tt>
--   interface supports adding children at the start or end sides by
--   specifying “start” or “end” as the “type” attribute of a
--   <tt>&lt;child&gt;</tt> element, or setting the center widget by
--   specifying “center” value.
--   
--   <h1>CSS nodes</h1>
--   
--   <pre>
--   actionbar
--   ╰── revealer
--       ╰── box
--           ├── box.start
--           │   ╰── [start children]
--           ├── [center widget]
--           ╰── box.end
--               ╰── [end children]
--   </pre>
--   
--   A <tt>GtkActionBar</tt>'s CSS node is called <tt>actionbar</tt>. It
--   contains a <tt>revealer</tt> subnode, which contains a <tt>box</tt>
--   subnode, which contains two <tt>box</tt> subnodes at the start and end
--   of the action bar, with <tt>start</tt> and <tt>end</tt> style classes
--   respectively, as well as a center node that represents the center
--   child.
--   
--   Each of the boxes contains children packed for that side.
module GI.Gtk.Objects.ActionBar

-- | Memory-managed wrapper type.
newtype ActionBar
ActionBar :: ManagedPtr ActionBar -> ActionBar

-- | Type class for types which can be safely cast to <a>ActionBar</a>, for
--   instance with <a>toActionBar</a>.
class (GObject o, IsDescendantOf ActionBar o) => IsActionBar o

-- | Cast to <a>ActionBar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toActionBar :: (MonadIO m, IsActionBar o) => o -> m ActionBar

-- | Retrieves the center bar widget of the bar.
actionBarGetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a) => a -> m (Maybe Widget)

-- | Gets whether the contents of the action bar are revealed.
actionBarGetRevealed :: (HasCallStack, MonadIO m, IsActionBar a) => a -> m Bool

-- | Creates a new action bar widget.
actionBarNew :: (HasCallStack, MonadIO m) => m ActionBar

-- | Adds a child to the action bar, packed with reference to the end of
--   the action bar.
actionBarPackEnd :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> b -> m ()

-- | Adds a child to the action, packed with reference to the start of the
--   action bar.
actionBarPackStart :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> b -> m ()

-- | Removes a child from the action bar.
actionBarRemove :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> b -> m ()

-- | Sets the center widget for the action bar.
actionBarSetCenterWidget :: (HasCallStack, MonadIO m, IsActionBar a, IsWidget b) => a -> Maybe b -> m ()

-- | Reveals or conceals the content of the action bar.
--   
--   Note: this does not show or hide the action bar in the
--   <a>Widget:visible</a> sense, so revealing has no effect if the action
--   bar is hidden.
actionBarSetRevealed :: (HasCallStack, MonadIO m, IsActionBar a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>revealed</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructActionBarRevealed :: (IsActionBar o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionBar #revealed
--   </pre>
getActionBarRevealed :: (MonadIO m, IsActionBar o) => o -> m Bool

-- | Set the value of the “<tt>revealed</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionBar [ #revealed <a>:=</a> value ]
--   </pre>
setActionBarRevealed :: (MonadIO m, IsActionBar o) => o -> Bool -> m ()
instance GHC.Classes.Eq GI.Gtk.Objects.ActionBar.ActionBar
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.ActionBar.ActionBar
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.ActionBar.ActionBar
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.ActionBar.ActionBar o) => GI.Gtk.Objects.ActionBar.IsActionBar o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.ActionBar.ActionBar)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.ActionBar.ActionBar
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.ActionBar.ActionBar


-- | Displays information about a program.
--   
--   The shown information includes the programs' logo, name, copyright,
--   website and license. It is also possible to give credits to the
--   authors, documenters, translators and artists who have worked on the
--   program.
--   
--   An about dialog is typically opened when the user selects the
--   <tt>About</tt> option from the <tt>Help</tt> menu. All parts of the
--   dialog are optional.
--   
--   &lt;picture&gt; &lt;source srcset="aboutdialot-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="An example
--   GtkAboutDialog" src="aboutdialog.png"&gt; &lt;/picture&gt;
--   
--   About dialogs often contain links and email addresses.
--   <tt>GtkAboutDialog</tt> displays these as clickable links. By default,
--   it calls <a>fileLauncherLaunch</a> when a user clicks one. The
--   behaviour can be overridden with the <a>AboutDialog::activateLink</a>
--   signal.
--   
--   To specify a person with an email address, use a string like <tt>Edgar
--   Allan Poe &lt;edgar@poe.com&gt;</tt>. To specify a website with a
--   title, use a string like <tt>GTK team https://www.gtk.org</tt>.
--   
--   To make constructing an about dialog as convenient as possible, you
--   can use the function <tt><i>Gtk.show_about_dialog</i></tt> which
--   constructs and shows a dialog and keeps it around so that it can be
--   shown again.
--   
--   Note that GTK sets a default title of <tt>_("About %s")</tt> on the
--   dialog window (where <tt>%s</tt> is replaced by the name of the
--   application, but in order to ensure proper translation of the title,
--   applications should set the title property explicitly when
--   constructing an about dialog, as shown in the following example:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GFile *logo_file = g_file_new_for_path ("./logo.png");
--   GdkTexture *example_logo = gdk_texture_new_from_file (logo_file, NULL);
--   g_object_unref (logo_file);
--   
--   gtk_show_about_dialog (NULL,
--                          "program-name", "ExampleCode",
--                          "logo", example_logo,
--                          "title", _("About ExampleCode"),
--                          NULL);
--   </pre>
--   
--   <h2>Shortcuts and Gestures</h2>
--   
--   <tt>GtkAboutDialog</tt> supports the following keyboard shortcuts:
--   
--   <ul>
--   <li>&lt;kbd&gt;Escape&lt;/kbd&gt; closes the window.</li>
--   </ul>
--   
--   <h2>CSS nodes</h2>
--   
--   <tt>GtkAboutDialog</tt> has a single CSS node with the name
--   <tt>window</tt> and style class <tt>.aboutdialog</tt>.
module GI.Gtk.Objects.AboutDialog

-- | Memory-managed wrapper type.
newtype AboutDialog
AboutDialog :: ManagedPtr AboutDialog -> AboutDialog

-- | Type class for types which can be safely cast to <a>AboutDialog</a>,
--   for instance with <a>toAboutDialog</a>.
class (GObject o, IsDescendantOf AboutDialog o) => IsAboutDialog o

-- | Cast to <a>AboutDialog</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAboutDialog :: (MonadIO m, IsAboutDialog o) => o -> m AboutDialog

-- | Creates a new section in the "Credits" page.
aboutDialogAddCreditSection :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Text -> [Text] -> m ()

-- | Returns the names of the artists which are displayed in the credits
--   page.
aboutDialogGetArtists :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the names of the authors which are displayed in the credits
--   page.
aboutDialogGetAuthors :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the comments string.
aboutDialogGetComments :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the copyright string.
aboutDialogGetCopyright :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the name of the documenters which are displayed in the credits
--   page.
aboutDialogGetDocumenters :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m [Text]

-- | Returns the license information.
aboutDialogGetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Retrieves the license type.
aboutDialogGetLicenseType :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m License

-- | Returns the paintable displayed as logo in the about dialog.
aboutDialogGetLogo :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Paintable)

-- | Returns the icon name displayed as logo in the about dialog.
aboutDialogGetLogoIconName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the program name displayed in the about dialog.
aboutDialogGetProgramName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the system information that is shown in the about dialog.
aboutDialogGetSystemInformation :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the translator credits string which is displayed in the
--   credits page.
aboutDialogGetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the version string.
aboutDialogGetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the website URL.
aboutDialogGetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns the label used for the website link.
aboutDialogGetWebsiteLabel :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m (Maybe Text)

-- | Returns whether the license text in the about dialog is automatically
--   wrapped.
aboutDialogGetWrapLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> m Bool

-- | Creates a new <tt>GtkAboutDialog</tt>.
aboutDialogNew :: (HasCallStack, MonadIO m) => m AboutDialog

-- | Sets the names of the artists to be displayed in the "Credits" page.
aboutDialogSetArtists :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the names of the authors which are displayed in the "Credits"
--   page of the about dialog.
aboutDialogSetAuthors :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the comments string to display in the about dialog.
--   
--   This should be a short string of one or two lines.
aboutDialogSetComments :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the copyright string to display in the about dialog.
--   
--   This should be a short string of one or two lines.
aboutDialogSetCopyright :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the names of the documenters which are displayed in the "Credits"
--   page.
aboutDialogSetDocumenters :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> [Text] -> m ()

-- | Sets the license information to be displayed in the about dialog.
--   
--   If <tt>license</tt> is <tt>NULL</tt>, the license page is hidden.
aboutDialogSetLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the license of the application showing the about dialog from a
--   list of known licenses.
--   
--   This function overrides the license set using
--   <a>aboutDialogSetLicense</a>.
aboutDialogSetLicenseType :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> License -> m ()

-- | Sets the logo in the about dialog.
aboutDialogSetLogo :: (HasCallStack, MonadIO m, IsAboutDialog a, IsPaintable b) => a -> Maybe b -> m ()

-- | Sets the icon name to be displayed as logo in the about dialog.
aboutDialogSetLogoIconName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the name to display in the about dialog.
--   
--   If <tt>name</tt> is not set, the string returned by
--   <tt>g_get_application_name()</tt> is used.
aboutDialogSetProgramName :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the system information to be displayed in the about dialog.
--   
--   If <tt>system_information</tt> is <tt>NULL</tt>, the system
--   information page is hidden.
--   
--   See <a>AboutDialog:systemInformation</a>.
aboutDialogSetSystemInformation :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the translator credits string which is displayed in the credits
--   page.
--   
--   The intended use for this string is to display the translator of the
--   language which is currently used in the user interface. Using
--   <tt>gettext()</tt>, a simple way to achieve that is to mark the string
--   for translation:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWidget *about = gtk_about_dialog_new ();
--    gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about),
--                                             _("translator-credits"));
--   </pre>
--   
--   It is a good idea to use the customary <tt>msgid</tt>
--   “translator-credits” for this purpose, since translators will already
--   know the purpose of that <tt>msgid</tt>, and since
--   <tt>GtkAboutDialog</tt> will detect if “translator-credits” is
--   untranslated and omit translator credits.
aboutDialogSetTranslatorCredits :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the version string to display in the about dialog.
aboutDialogSetVersion :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the URL to use for the website link.
aboutDialogSetWebsite :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Maybe Text -> m ()

-- | Sets the label to be used for the website link.
aboutDialogSetWebsiteLabel :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Text -> m ()

-- | Sets whether the license text in the about dialog should be
--   automatically wrapped.
aboutDialogSetWrapLicense :: (HasCallStack, MonadIO m, IsAboutDialog a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>artists</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogArtists :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>artists</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #artists
--   </pre>
getAboutDialogArtists :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “<tt>artists</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #artists <a>:=</a> value ]
--   </pre>
setAboutDialogArtists :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>authors</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogAuthors :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>authors</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #authors
--   </pre>
getAboutDialogAuthors :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “<tt>authors</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #authors <a>:=</a> value ]
--   </pre>
setAboutDialogAuthors :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Set the value of the “<tt>comments</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #comments
--   </pre>
clearAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>comments</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAboutDialogComments :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>comments</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #comments
--   </pre>
getAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>comments</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #comments <a>:=</a> value ]
--   </pre>
setAboutDialogComments :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>copyright</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #copyright
--   </pre>
clearAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>copyright</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructAboutDialogCopyright :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>copyright</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #copyright
--   </pre>
getAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>copyright</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #copyright <a>:=</a> value ]
--   </pre>
setAboutDialogCopyright :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>documenters</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogDocumenters :: (IsAboutDialog o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>documenters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #documenters
--   </pre>
getAboutDialogDocumenters :: (MonadIO m, IsAboutDialog o) => o -> m [Text]

-- | Set the value of the “<tt>documenters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #documenters <a>:=</a> value ]
--   </pre>
setAboutDialogDocumenters :: (MonadIO m, IsAboutDialog o) => o -> [Text] -> m ()

-- | Set the value of the “<tt>license</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #license
--   </pre>
clearAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>license</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogLicense :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #license
--   </pre>
getAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #license <a>:=</a> value ]
--   </pre>
setAboutDialogLicense :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>license-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogLicenseType :: (IsAboutDialog o, MonadIO m) => License -> m (GValueConstruct o)

-- | Get the value of the “<tt>license-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #licenseType
--   </pre>
getAboutDialogLicenseType :: (MonadIO m, IsAboutDialog o) => o -> m License

-- | Set the value of the “<tt>license-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #licenseType <a>:=</a> value ]
--   </pre>
setAboutDialogLicenseType :: (MonadIO m, IsAboutDialog o) => o -> License -> m ()

-- | Set the value of the “<tt>logo</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #logo
--   </pre>
clearAboutDialogLogo :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>logo</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogLogo :: (IsAboutDialog o, MonadIO m, IsPaintable a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>logo</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #logo
--   </pre>
getAboutDialogLogo :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Paintable)

-- | Set the value of the “<tt>logo</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #logo <a>:=</a> value ]
--   </pre>
setAboutDialogLogo :: (MonadIO m, IsAboutDialog o, IsPaintable a) => o -> a -> m ()

-- | Set the value of the “<tt>logo-icon-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #logoIconName
--   </pre>
clearAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>logo-icon-name</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructAboutDialogLogoIconName :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>logo-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #logoIconName
--   </pre>
getAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>logo-icon-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #logoIconName <a>:=</a> value ]
--   </pre>
setAboutDialogLogoIconName :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>program-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #programName
--   </pre>
clearAboutDialogProgramName :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>program-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogProgramName :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>program-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #programName
--   </pre>
getAboutDialogProgramName :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>program-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #programName <a>:=</a> value ]
--   </pre>
setAboutDialogProgramName :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>system-information</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #systemInformation
--   </pre>
clearAboutDialogSystemInformation :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>system-information</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructAboutDialogSystemInformation :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>system-information</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #systemInformation
--   </pre>
getAboutDialogSystemInformation :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>system-information</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #systemInformation <a>:=</a> value ]
--   </pre>
setAboutDialogSystemInformation :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>translator-credits</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #translatorCredits
--   </pre>
clearAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>translator-credits</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructAboutDialogTranslatorCredits :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>translator-credits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #translatorCredits
--   </pre>
getAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>translator-credits</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #translatorCredits <a>:=</a> value ]
--   </pre>
setAboutDialogTranslatorCredits :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>version</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #version
--   </pre>
clearAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>version</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogVersion :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>version</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #version
--   </pre>
getAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>version</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #version <a>:=</a> value ]
--   </pre>
setAboutDialogVersion :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Set the value of the “<tt>website</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #website
--   </pre>
clearAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>website</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructAboutDialogWebsite :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>website</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #website
--   </pre>
getAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>website</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #website <a>:=</a> value ]
--   </pre>
setAboutDialogWebsite :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>website-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogWebsiteLabel :: (IsAboutDialog o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>website-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #websiteLabel
--   </pre>
getAboutDialogWebsiteLabel :: (MonadIO m, IsAboutDialog o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>website-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #websiteLabel <a>:=</a> value ]
--   </pre>
setAboutDialogWebsiteLabel :: (MonadIO m, IsAboutDialog o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>wrap-license</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAboutDialogWrapLicense :: (IsAboutDialog o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>wrap-license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> aboutDialog #wrapLicense
--   </pre>
getAboutDialogWrapLicense :: (MonadIO m, IsAboutDialog o) => o -> m Bool

-- | Set the value of the “<tt>wrap-license</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> aboutDialog [ #wrapLicense <a>:=</a> value ]
--   </pre>
setAboutDialogWrapLicense :: (MonadIO m, IsAboutDialog o) => o -> Bool -> m ()

-- | Emitted every time a URL is activated.
--   
--   Applications may connect to it to override the default behaviour,
--   which is to call <a>fileLauncherLaunch</a>.
type AboutDialogActivateLinkCallback = Text -> IO Bool

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> aboutDialog #activateLink callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAboutDialogActivateLink :: (IsAboutDialog a, MonadIO m) => a -> ((?self :: a) => AboutDialogActivateLinkCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>activateLink</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> aboutDialog #activateLink callback
--   </pre>
onAboutDialogActivateLink :: (IsAboutDialog a, MonadIO m) => a -> ((?self :: a) => AboutDialogActivateLinkCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Objects.AboutDialog.AboutDialog
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Objects.AboutDialog.AboutDialog
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Objects.AboutDialog.AboutDialog
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Objects.AboutDialog.AboutDialog o) => GI.Gtk.Objects.AboutDialog.IsAboutDialog o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Objects.AboutDialog.AboutDialog)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Objects.AboutDialog.AboutDialog
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Objects.AboutDialog.AboutDialog


module GI.Gtk.Objects


-- | The interface for sortable models used by GtkTreeView
--   
--   <tt>GtkTreeSortable</tt> is an interface to be implemented by tree
--   models which support sorting. The <tt>GtkTreeView</tt> uses the
--   methods provided by this interface to sort the model.
module GI.Gtk.Interfaces.TreeSortable

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)There is no replacement for this
--   interface. You shoulduse <a>SortListModel</a> to wrap your list model
--   instead</i>
newtype TreeSortable

-- | <i>Deprecated: (Since version 4.10)There is no replacement for this
--   interface. You shoulduse <a>SortListModel</a> to wrap your list model
--   instead</i>
TreeSortable :: ManagedPtr TreeSortable -> TreeSortable

-- | Type class for types which can be safely cast to <a>TreeSortable</a>,
--   for instance with <a>toTreeSortable</a>.
class (GObject o, IsDescendantOf TreeSortable o) => IsTreeSortable o

-- | Cast to <a>TreeSortable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeSortable :: (MonadIO m, IsTreeSortable o) => o -> m TreeSortable

-- | Fills in <i><tt>sortColumnId</tt></i> and <i><tt>order</tt></i> with
--   the current sort column and the order. It returns <a>True</a> unless
--   the <i><tt>sortColumnId</tt></i> is
--   <a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a> or
--   <a>TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeSortableGetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m (Bool, Int32, SortType)

-- | Returns <a>True</a> if the model has a default sort function. This is
--   used primarily by GtkTreeViewColumns in order to determine if a model
--   can go back to the default state, or not.

-- | <i>Deprecated: (Since version 4.10)</i>
treeSortableHasDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m Bool

-- | Sets the default comparison function used when sorting to be
--   <i><tt>sortFunc</tt></i>. If the current sort column id of
--   <i><tt>sortable</tt></i> is
--   <a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a>, then the model will sort
--   using this function.
--   
--   If <i><tt>sortFunc</tt></i> is <a>Nothing</a>, then there will be no
--   default comparison function. This means that once the model has been
--   sorted, it can’t go back to the default state. In this case, when the
--   current sort column id of <i><tt>sortable</tt></i> is
--   <a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a>, the model will be
--   unsorted.

-- | <i>Deprecated: (Since version 4.10)</i>
treeSortableSetDefaultSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> TreeIterCompareFunc -> m ()

-- | Sets the current sort column to be <i><tt>sortColumnId</tt></i>. The
--   <i><tt>sortable</tt></i> will resort itself to reflect this change,
--   after emitting a <tt>GtkTreeSortable::sort-column-changed</tt> signal.
--   <i><tt>sortColumnId</tt></i> may either be a regular column id, or one
--   of the following special values:
--   
--   <ul>
--   <li><a>TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</a>: the default sort
--   function will be used, if it is set</li>
--   <li><a>TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID</a>: no sorting will
--   occur</li>
--   </ul>

-- | <i>Deprecated: (Since version 4.10)</i>
treeSortableSetSortColumnId :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> Int32 -> SortType -> m ()

-- | Sets the comparison function used when sorting to be
--   <i><tt>sortFunc</tt></i>. If the current sort column id of
--   <i><tt>sortable</tt></i> is the same as <i><tt>sortColumnId</tt></i>,
--   then the model will sort using this function.

-- | <i>Deprecated: (Since version 4.10)</i>
treeSortableSetSortFunc :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> Int32 -> TreeIterCompareFunc -> m ()

-- | Emits a <tt>GtkTreeSortable::sort-column-changed</tt> signal on
--   <i><tt>sortable</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeSortableSortColumnChanged :: (HasCallStack, MonadIO m, IsTreeSortable a) => a -> m ()

-- | The <a>sortColumnChanged</a> signal is emitted when the sort column or
--   sort order of <i><tt>sortable</tt></i> is changed. The signal is
--   emitted before the contents of <i><tt>sortable</tt></i> are resorted.
type TreeSortableSortColumnChangedCallback = IO ()

-- | Connect a signal handler for the <a>sortColumnChanged</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeSortable #sortColumnChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>sortColumnChanged</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeSortable #sortColumnChanged callback
--   </pre>
onTreeSortableSortColumnChanged :: (IsTreeSortable a, MonadIO m) => a -> ((?self :: a) => TreeSortableSortColumnChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.TreeSortable.TreeSortable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.TreeSortable.TreeSortable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.TreeSortable.TreeSortable
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.TreeSortable.TreeSortable)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.TreeSortable.TreeSortable o) => GI.Gtk.Interfaces.TreeSortable.IsTreeSortable o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.TreeSortable.TreeSortable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.TreeSortable.TreeSortable


-- | The tree interface used by GtkTreeView
--   
--   The <tt>GtkTreeModel</tt> interface defines a generic tree interface
--   for use by the <tt>GtkTreeView</tt> widget. It is an abstract
--   interface, and is designed to be usable with any appropriate data
--   structure. The programmer just has to implement this interface on
--   their own data type for it to be viewable by a <tt>GtkTreeView</tt>
--   widget.
--   
--   The model is represented as a hierarchical tree of strongly-typed,
--   columned data. In other words, the model can be seen as a tree where
--   every node has different values depending on which column is being
--   queried. The type of data found in a column is determined by using the
--   GType system (ie. <tt><i>G_TYPE_INT</i></tt>,
--   <tt><i>GTK_TYPE_BUTTON</i></tt>, <tt><i>G_TYPE_POINTER</i></tt>, etc).
--   The types are homogeneous per column across all nodes. It is important
--   to note that this interface only provides a way of examining a model
--   and observing changes. The implementation of each individual model
--   decides how and if changes are made.
--   
--   In order to make life simpler for programmers who do not need to write
--   their own specialized model, two generic models are provided — the
--   <tt>GtkTreeStore</tt> and the <tt>GtkListStore</tt>. To use these, the
--   developer simply pushes data into these models as necessary. These
--   models provide the data structure as well as all appropriate tree
--   interfaces. As a result, implementing drag and drop, sorting, and
--   storing data is trivial. For the vast majority of trees and lists,
--   these two models are sufficient.
--   
--   Models are accessed on a node/column level of granularity. One can
--   query for the value of a model at a certain node and a certain column
--   on that node. There are two structures used to reference a particular
--   node in a model. They are the <a>TreePath</a> and the <a>TreeIter</a>
--   (“iter” is short for iterator). Most of the interface consists of
--   operations on a <a>TreeIter</a>.
--   
--   A path is essentially a potential node. It is a location on a model
--   that may or may not actually correspond to a node on a specific model.
--   A <a>TreePath</a> can be converted into either an array of unsigned
--   integers or a string. The string form is a list of numbers separated
--   by a colon. Each number refers to the offset at that level. Thus, the
--   path <tt>0</tt> refers to the root node and the path <tt>2:4</tt>
--   refers to the fifth child of the third node.
--   
--   By contrast, a <a>TreeIter</a> is a reference to a specific node on a
--   specific model. It is a generic struct with an integer and three
--   generic pointers. These are filled in by the model in a model-specific
--   way. One can convert a path to an iterator by calling
--   <a>treeModelGetIter</a>. These iterators are the primary way of
--   accessing a model and are similar to the iterators used by
--   <tt>GtkTextBuffer</tt>. They are generally statically allocated on the
--   stack and only used for a short time. The model interface defines a
--   set of operations using them for navigating the model.
--   
--   It is expected that models fill in the iterator with private data. For
--   example, the <tt>GtkListStore</tt> model, which is internally a simple
--   linked list, stores a list node in one of the pointers. The
--   <tt>GtkTreeModel</tt>Sort stores an array and an offset in two of the
--   pointers. Additionally, there is an integer field. This field is
--   generally filled with a unique stamp per model. This stamp is for
--   catching errors resulting from using invalid iterators with a model.
--   
--   The lifecycle of an iterator can be a little confusing at first.
--   Iterators are expected to always be valid for as long as the model is
--   unchanged (and doesn’t emit a signal). The model is considered to own
--   all outstanding iterators and nothing needs to be done to free them
--   from the user’s point of view. Additionally, some models guarantee
--   that an iterator is valid for as long as the node it refers to is
--   valid (most notably the <tt>GtkTreeStore</tt> and
--   <tt>GtkListStore</tt>). Although generally uninteresting, as one
--   always has to allow for the case where iterators do not persist beyond
--   a signal, some very important performance enhancements were made in
--   the sort model. As a result, the <a>TreeModelFlagsItersPersist</a>
--   flag was added to indicate this behavior.
--   
--   To help show some common operation of a model, some examples are
--   provided. The first example shows three ways of getting the iter at
--   the location <tt>3:2:5</tt>. While the first method shown is easier,
--   the second is much more common, as you often get paths from callbacks.
--   
--   <h2>Acquiring a <tt>GtkTreeIter</tt></h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   // Three ways of getting the iter pointing to the location
--   GtkTreePath *path;
--   GtkTreeIter iter;
--   GtkTreeIter parent_iter;
--   
--   // get the iterator from a string
--   gtk_tree_model_get_iter_from_string (model,
--                                        &amp;iter,
--                                        "3:2:5");
--   
--   // get the iterator from a path
--   path = gtk_tree_path_new_from_string ("3:2:5");
--   gtk_tree_model_get_iter (model, &amp;iter, path);
--   gtk_tree_path_free (path);
--   
--   // walk the tree to find the iterator
--   gtk_tree_model_iter_nth_child (model, &amp;iter,
--                                  NULL, 3);
--   parent_iter = iter;
--   gtk_tree_model_iter_nth_child (model, &amp;iter,
--                                  &amp;parent_iter, 2);
--   parent_iter = iter;
--   gtk_tree_model_iter_nth_child (model, &amp;iter,
--                                  &amp;parent_iter, 5);
--   </pre>
--   
--   This second example shows a quick way of iterating through a list and
--   getting a string and an integer from each row. The
--   <tt><i>populate_model()</i></tt> function used below is not shown, as
--   it is specific to the <tt>GtkListStore</tt>. For information on how to
--   write such a function, see the <tt>GtkListStore</tt> documentation.
--   
--   <h2>Reading data from a <tt>GtkTreeModel</tt></h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   enum
--   {
--     STRING_COLUMN,
--     INT_COLUMN,
--     N_COLUMNS
--   };
--   
--   ...
--   
--   GtkTreeModel *list_store;
--   GtkTreeIter iter;
--   gboolean valid;
--   int row_count = 0;
--   
--   // make a new list_store
--   list_store = gtk_list_store_new (N_COLUMNS,
--                                    G_TYPE_STRING,
--                                    G_TYPE_INT);
--   
--   // Fill the list store with data
--   populate_model (list_store);
--   
--   // Get the first iter in the list, check it is valid and walk
--   // through the list, reading each row.
--   
--   valid = gtk_tree_model_get_iter_first (list_store,
--                                          &amp;iter);
--   while (valid)
--    {
--      char *str_data;
--      int    int_data;
--   
--      // Make sure you terminate calls to gtk_tree_model_get() with a “-1” value
--      gtk_tree_model_get (list_store, &amp;iter,
--                          STRING_COLUMN, &amp;str_data,
--                          INT_COLUMN, &amp;int_data,
--                          -1);
--   
--      // Do something with the data
--      g_print ("Row %d: (%s,%d)\n",
--               row_count, str_data, int_data);
--      g_free (str_data);
--   
--      valid = gtk_tree_model_iter_next (list_store,
--                                        &amp;iter);
--      row_count++;
--    }
--   </pre>
--   
--   The <tt>GtkTreeModel</tt> interface contains two methods for reference
--   counting: <a>treeModelRefNode</a> and <a>treeModelUnrefNode</a>. These
--   two methods are optional to implement. The reference counting is meant
--   as a way for views to let models know when nodes are being displayed.
--   <tt>GtkTreeView</tt> will take a reference on a node when it is
--   visible, which means the node is either in the toplevel or expanded.
--   Being displayed does not mean that the node is currently directly
--   visible to the user in the viewport. Based on this reference counting
--   scheme a caching model, for example, can decide whether or not to
--   cache a node based on the reference count. A file-system based model
--   would not want to keep the entire file hierarchy in memory, but just
--   the folders that are currently expanded in every current view.
--   
--   When working with reference counting, the following rules must be
--   taken into account:
--   
--   <ul>
--   <li>Never take a reference on a node without owning a reference on its
--   parent. This means that all parent nodes of a referenced node must be
--   referenced as well.</li>
--   <li>Outstanding references on a deleted node are not released. This is
--   not possible because the node has already been deleted by the time the
--   row-deleted signal is received.</li>
--   <li>Models are not obligated to emit a signal on rows of which none of
--   its siblings are referenced. To phrase this differently, signals are
--   only required for levels in which nodes are referenced. For the root
--   level however, signals must be emitted at all times (however the root
--   level is always referenced when any view is attached).</li>
--   </ul>
module GI.Gtk.Interfaces.TreeModel

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)Use <a>ListModel</a> instead</i>
newtype TreeModel

-- | <i>Deprecated: (Since version 4.10)Use <a>ListModel</a> instead</i>
TreeModel :: ManagedPtr TreeModel -> TreeModel

-- | Type class for types which can be safely cast to <a>TreeModel</a>, for
--   instance with <a>toTreeModel</a>.
class (GObject o, IsDescendantOf TreeModel o) => IsTreeModel o

-- | Cast to <a>TreeModel</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeModel :: (MonadIO m, IsTreeModel o) => o -> m TreeModel

-- | Creates a new <tt>GtkTreeModel</tt>, with <i><tt>childModel</tt></i>
--   as the child_model and <i><tt>root</tt></i> as the virtual root.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelFilterNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreePath -> m TreeModel

-- | Calls <i><tt>func</tt></i> on each node in model in a depth-first
--   fashion.
--   
--   If <i><tt>func</tt></i> returns <a>True</a>, then the tree ceases to
--   be walked, and <a>treeModelForeach</a> returns.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelForeach :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeModelForeachFunc -> m ()

-- | Returns the type of the column.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetColumnType :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Int32 -> m GType

-- | Returns a set of flags supported by this interface.
--   
--   The flags are a bitwise combination of <tt>GtkTreeModel</tt>Flags. The
--   flags supported should not change during the lifetime of the
--   <i><tt>treeModel</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetFlags :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m [TreeModelFlags]

-- | Sets <i><tt>iter</tt></i> to a valid iterator pointing to
--   <i><tt>path</tt></i>.
--   
--   If <i><tt>path</tt></i> does not exist, <i><tt>iter</tt></i> is set to
--   an invalid iterator and <a>False</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m (Bool, TreeIter)

-- | Initializes <i><tt>iter</tt></i> with the first iterator in the tree
--   (the one at the path "0").
--   
--   Returns <a>False</a> if the tree is empty, <a>True</a> otherwise.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetIterFirst :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to a valid iterator pointing to
--   <i><tt>pathString</tt></i>, if it exists.
--   
--   Otherwise, <i><tt>iter</tt></i> is left invalid and <a>False</a> is
--   returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetIterFromString :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Text -> m (Bool, TreeIter)

-- | Returns the number of columns supported by <i><tt>treeModel</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetNColumns :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> m Int32

-- | Returns a newly-created <tt>GtkTreePath</tt> referenced by
--   <i><tt>iter</tt></i>.
--   
--   This path should be freed with <a>treePathFree</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetPath :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m TreePath

-- | 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.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetStringFromIter :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m (Maybe Text)

-- | Initializes and sets <i><tt>value</tt></i> to that at
--   <i><tt>column</tt></i>.
--   
--   When done with <i><tt>value</tt></i>, <a>valueUnset</a> needs to be
--   called to free any allocated memory.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelGetValue :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> Int32 -> m GValue

-- | Sets <i><tt>iter</tt></i> to point to the first child of
--   <i><tt>parent</tt></i>.
--   
--   If <i><tt>parent</tt></i> has no children, <a>False</a> is returned
--   and <i><tt>iter</tt></i> is set to be invalid. <i><tt>parent</tt></i>
--   will remain a valid node after this function has been called.
--   
--   If <i><tt>parent</tt></i> is <a>Nothing</a> returns the first node,
--   equivalent to <tt>gtk_tree_model_get_iter_first (tree_model,
--   iter);</tt>

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelIterChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m (Bool, TreeIter)

-- | Returns <a>True</a> if <i><tt>iter</tt></i> has children, <a>False</a>
--   otherwise.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelIterHasChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Returns the number of children that <i><tt>iter</tt></i> has.
--   
--   As a special case, if <i><tt>iter</tt></i> is <a>Nothing</a>, then the
--   number of toplevel nodes is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelIterNChildren :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> Maybe TreeIter -> m Int32

-- | Sets <i><tt>iter</tt></i> to point to the node following it at the
--   current level.
--   
--   If there is no next <i><tt>iter</tt></i>, <a>False</a> is returned and
--   <i><tt>iter</tt></i> is set to be invalid.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelIterNext :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Sets <i><tt>iter</tt></i> to be the child of <i><tt>parent</tt></i>,
--   using the given index.
--   
--   The first index is 0. If <i><tt>n</tt></i> is too big, or
--   <i><tt>parent</tt></i> has no children, <i><tt>iter</tt></i> is set to
--   an invalid iterator and <a>False</a> is returned.
--   <i><tt>parent</tt></i> will remain a valid node after this function
--   has been called. As a special case, if <i><tt>parent</tt></i> is
--   <a>Nothing</a>, then the <i><tt>n</tt></i>-th root node is set.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelIterNthChild :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> Maybe TreeIter -> Int32 -> m Bool

-- | Sets <i><tt>iter</tt></i> to be the parent of <i><tt>child</tt></i>.
--   
--   If <i><tt>child</tt></i> is at the toplevel, and doesn’t have a
--   parent, then <i><tt>iter</tt></i> is set to an invalid iterator and
--   <a>False</a> is returned. <i><tt>child</tt></i> will remain a valid
--   node after this function has been called.
--   
--   <i><tt>iter</tt></i> will be initialized before the lookup is
--   performed, so <i><tt>child</tt></i> and <i><tt>iter</tt></i> cannot
--   point to the same memory location.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelIterParent :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m (Bool, TreeIter)

-- | Sets <i><tt>iter</tt></i> to point to the previous node at the current
--   level.
--   
--   If there is no previous <i><tt>iter</tt></i>, <a>False</a> is returned
--   and <i><tt>iter</tt></i> is set to be invalid.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelIterPrevious :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m Bool

-- | Lets the tree ref the node.
--   
--   This is an optional method for models to implement. To be more
--   specific, models may ignore this call as it exists primarily for
--   performance reasons.
--   
--   This function is primarily meant as a way for views to let caching
--   models know when nodes are being displayed (and hence, whether or not
--   to cache that node). Being displayed means a node is in an expanded
--   branch, regardless of whether the node is currently visible in the
--   viewport. For example, a file-system based model would not want to
--   keep the entire file-hierarchy in memory, just the sections that are
--   currently being displayed by every current view.
--   
--   A model should be expected to be able to get an iter independent of
--   its reffed state.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelRefNode :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m ()

-- | Emits the <a>rowChanged</a> signal on <i><tt>treeModel</tt></i>.
--   
--   See <a>TreeModel::rowChanged</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelRowChanged :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>rowDeleted</a> signal on <i><tt>treeModel</tt></i>.
--   
--   See <a>TreeModel::rowDeleted</a>.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by <i><tt>path</tt></i> should be the location
--   that the row previously was at. It may not be a valid location
--   anymore.
--   
--   Nodes that are deleted are not unreffed, this means that any
--   outstanding references on the deleted node should not be released.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelRowDeleted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m ()

-- | Emits the <a>rowHasChildToggled</a> signal on
--   <i><tt>treeModel</tt></i>.
--   
--   See <a>TreeModel::rowHasChildToggled</a>.
--   
--   This should be called by models after the child state of a node
--   changes.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelRowHasChildToggled :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>rowInserted</a> signal on <i><tt>treeModel</tt></i>.
--   
--   See <a>TreeModel::rowInserted</a>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelRowInserted :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> TreeIter -> m ()

-- | Emits the <a>rowsReordered</a> signal on <i><tt>treeModel</tt></i>.
--   
--   See <a>TreeModel</a>::<tt><i>rows-reordered</i></tt>.
--   
--   This should be called by models when their rows have been reordered.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelRowsReordered :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> Maybe TreeIter -> [Int32] -> m ()

-- | Lets the tree unref the node.
--   
--   This is an optional method for models to implement. To be more
--   specific, models may ignore this call as it exists primarily for
--   performance reasons. For more information on what this means, see
--   <a>treeModelRefNode</a>.
--   
--   Please note that nodes that are deleted are not unreffed.

-- | <i>Deprecated: (Since version 4.10)</i>
treeModelUnrefNode :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreeIter -> m ()

-- | This signal is emitted when a row in the model has changed.
type TreeModelRowChangedCallback = TreePath -> TreeIter -> IO ()

-- | Connect a signal handler for the <a>rowChanged</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowChanged callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowChanged</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowChanged callback
--   </pre>
onTreeModelRowChanged :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowChangedCallback) -> m SignalHandlerId

-- | This signal is emitted when a row has been deleted.
--   
--   Note that no iterator is passed to the signal handler, since the row
--   is already deleted.
--   
--   This should be called by models after a row has been removed. The
--   location pointed to by <i><tt>path</tt></i> should be the location
--   that the row previously was at. It may not be a valid location
--   anymore.
type TreeModelRowDeletedCallback = TreePath -> IO ()

-- | Connect a signal handler for the <a>rowDeleted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowDeleted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowDeleted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowDeletedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowDeleted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowDeleted callback
--   </pre>
onTreeModelRowDeleted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowDeletedCallback) -> m SignalHandlerId

-- | This signal is emitted when a row has gotten the first child row or
--   lost its last child row.
type TreeModelRowHasChildToggledCallback = TreePath -> TreeIter -> IO ()

-- | Connect a signal handler for the <a>rowHasChildToggled</a> signal, to
--   be run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowHasChildToggled callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowHasChildToggled :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowHasChildToggledCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowHasChildToggled</a> signal, to
--   be run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowHasChildToggled callback
--   </pre>
onTreeModelRowHasChildToggled :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowHasChildToggledCallback) -> m SignalHandlerId

-- | This signal is emitted when a new row has been inserted in the model.
--   
--   Note that the row may still be empty at this point, since it is a
--   common pattern to first insert an empty row, and then fill it with the
--   desired values.
type TreeModelRowInsertedCallback = TreePath -> TreeIter -> IO ()

-- | Connect a signal handler for the <a>rowInserted</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> treeModel #rowInserted callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterTreeModelRowInserted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowInsertedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>rowInserted</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> treeModel #rowInserted callback
--   </pre>
onTreeModelRowInserted :: (IsTreeModel a, MonadIO m) => a -> ((?self :: a) => TreeModelRowInsertedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.TreeModel.TreeModel
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.TreeModel.TreeModel
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.TreeModel.TreeModel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.TreeModel.TreeModel)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.TreeModel.TreeModel o) => GI.Gtk.Interfaces.TreeModel.IsTreeModel o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.TreeModel.TreeModel
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.TreeModel.TreeModel


-- | An interface for widgets that can act as the root of a widget
--   hierarchy.
--   
--   The root widget takes care of providing the connection to the
--   windowing system and manages layout, drawing and event delivery for
--   its widget hierarchy.
--   
--   The obvious example of a <tt>GtkRoot</tt> is <tt>GtkWindow</tt>.
--   
--   To get the display to which a <tt>GtkRoot</tt> belongs, use
--   <a>rootGetDisplay</a>.
--   
--   <tt>GtkRoot</tt> also maintains the location of keyboard focus inside
--   its widget hierarchy, with <a>rootSetFocus</a> and
--   <a>rootGetFocus</a>.
module GI.Gtk.Interfaces.Root

-- | Memory-managed wrapper type.
newtype Root
Root :: ManagedPtr Root -> Root

-- | Type class for types which can be safely cast to <a>Root</a>, for
--   instance with <a>toRoot</a>.
class (GObject o, IsDescendantOf Root o) => IsRoot o

-- | Cast to <a>Root</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toRoot :: (MonadIO m, IsRoot o) => o -> m Root

-- | Returns the display that this <tt>GtkRoot</tt> is on.
rootGetDisplay :: (HasCallStack, MonadIO m, IsRoot a) => a -> m Display

-- | Retrieves the current focused widget within the root.
--   
--   Note that this is the widget that would have the focus if the root is
--   active; if the root is not focused then <tt>gtk_widget_has_focus
--   (widget)</tt> will be <a>False</a> for the widget.
rootGetFocus :: (HasCallStack, MonadIO m, IsRoot a) => a -> m (Maybe Widget)

-- | If <i><tt>focus</tt></i> is not the current focus widget, and is
--   focusable, sets it as the focus widget for the root.
--   
--   If <i><tt>focus</tt></i> is <a>Nothing</a>, unsets the focus widget
--   for the root.
--   
--   To set the focus to a particular widget in the root, it is usually
--   more convenient to use <a>widgetGrabFocus</a> instead of this
--   function.
rootSetFocus :: (HasCallStack, MonadIO m, IsRoot a, IsWidget b) => a -> Maybe b -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.Root.Root
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Root.Root
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Root.Root
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Root.Root)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Root.Root o) => GI.Gtk.Interfaces.Root.IsRoot o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Root.Root
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Root.Root


-- | An interface for widgets that have their own <a>Surface</a>.
--   
--   The obvious example of a <tt>GtkNative</tt> is <tt>GtkWindow</tt>.
--   
--   Every widget that is not itself a <tt>GtkNative</tt> is contained in
--   one, and you can get it with <a>widgetGetNative</a>.
--   
--   To get the surface of a <tt>GtkNative</tt>, use
--   <a>nativeGetSurface</a>. It is also possible to find the
--   <tt>GtkNative</tt> to which a surface belongs, with
--   <a>nativeGetForSurface</a>.
--   
--   In addition to a <a>Surface</a>, a <tt>GtkNative</tt> also provides a
--   <a>Renderer</a> for rendering on that surface. To get the renderer,
--   use <a>nativeGetRenderer</a>.
module GI.Gtk.Interfaces.Native

-- | Memory-managed wrapper type.
newtype Native
Native :: ManagedPtr Native -> Native

-- | Type class for types which can be safely cast to <a>Native</a>, for
--   instance with <a>toNative</a>.
class (GObject o, IsDescendantOf Native o) => IsNative o

-- | Cast to <a>Native</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toNative :: (MonadIO m, IsNative o) => o -> m Native

-- | Finds the <tt>GtkNative</tt> associated with the surface.
nativeGetForSurface :: (HasCallStack, MonadIO m, IsSurface a) => a -> m (Maybe Native)

-- | Returns the renderer that is used for this <tt>GtkNative</tt>.
nativeGetRenderer :: (HasCallStack, MonadIO m, IsNative a) => a -> m (Maybe Renderer)

-- | Returns the surface of this <tt>GtkNative</tt>.
nativeGetSurface :: (HasCallStack, MonadIO m, IsNative a) => a -> m (Maybe Surface)

-- | Retrieves the surface transform of <i><tt>self</tt></i>.
--   
--   This is the translation from <i><tt>self</tt></i>'s surface
--   coordinates into <i><tt>self</tt></i>'s widget coordinates.
nativeGetSurfaceTransform :: (HasCallStack, MonadIO m, IsNative a) => a -> m (Double, Double)

-- | Realizes a <tt>GtkNative</tt>.
--   
--   This should only be used by subclasses.
nativeRealize :: (HasCallStack, MonadIO m, IsNative a) => a -> m ()

-- | Unrealizes a <tt>GtkNative</tt>.
--   
--   This should only be used by subclasses.
nativeUnrealize :: (HasCallStack, MonadIO m, IsNative a) => a -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.Native.Native
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Native.Native
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Native.Native
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Native.Native)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Native.Native o) => GI.Gtk.Interfaces.Native.IsNative o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Native.Native
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Native.Native


-- | <tt>GtkFontChooser</tt> is an interface that can be implemented by
--   widgets for choosing fonts.
--   
--   In GTK, the main objects that implement this interface are
--   <a>FontChooserWidget</a>, <a>FontChooserDialog</a> and
--   <a>FontButton</a>.
module GI.Gtk.Interfaces.FontChooser

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
newtype FontChooser

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
FontChooser :: ManagedPtr FontChooser -> FontChooser

-- | Type class for types which can be safely cast to <a>FontChooser</a>,
--   for instance with <a>toFontChooser</a>.
class (GObject o, IsDescendantOf FontChooser o) => IsFontChooser o

-- | Cast to <a>FontChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontChooser :: (MonadIO m, IsFontChooser o) => o -> m FontChooser

-- | Gets the currently-selected font name.
--   
--   Note that this can be a different string than what you set with
--   <a>fontChooserSetFont</a>, as the font chooser widget may normalize
--   font names and thus return a string with a different structure. For
--   example, “Helvetica Italic Bold 12” could be normalized to “Helvetica
--   Bold Italic 12”.
--   
--   Use <a>fontDescriptionEqual</a> if you want to compare two font
--   descriptions.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetFont :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe Text)

-- | Gets the currently-selected font.
--   
--   Note that this can be a different string than what you set with
--   <a>fontChooserSetFont</a>, as the font chooser widget may normalize
--   font names and thus return a string with a different structure. For
--   example, “Helvetica Italic Bold 12” could be normalized to “Helvetica
--   Bold Italic 12”.
--   
--   Use <a>fontDescriptionEqual</a> if you want to compare two font
--   descriptions.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetFontDesc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontDescription)

-- | Gets the <tt>PangoFontFace</tt> representing the selected font group
--   details (i.e. family, slant, weight, width, etc).
--   
--   If the selected font is not installed, returns <a>Nothing</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetFontFace :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontFace)

-- | Gets the <tt>PangoFontFamily</tt> representing the selected font
--   family.
--   
--   Font families are a collection of font faces.
--   
--   If the selected font is not installed, returns <a>Nothing</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetFontFamily :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontFamily)

-- | Gets the currently-selected font features.
--   
--   The format of the returned string is compatible with the <a>CSS
--   font-feature-settings property</a>. It can be passed to
--   <a>attrFontFeaturesNew</a>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetFontFeatures :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Gets the custom font map of this font chooser widget, or
--   <a>Nothing</a> if it does not have one.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m (Maybe FontMap)

-- | The selected font size.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetFontSize :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Int32

-- | Gets the language that is used for font features.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Returns the current level of granularity for selecting fonts.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m [FontChooserLevel]

-- | Gets the text displayed in the preview area.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetPreviewText :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Text

-- | Returns whether the preview entry is shown or not.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserGetShowPreviewEntry :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> m Bool

-- | Adds a filter function that decides which fonts to display in the font
--   chooser.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetFilterFunc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Maybe FontFilterFunc -> m ()

-- | Sets the currently-selected font.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetFont :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Sets the currently-selected font from <i><tt>fontDesc</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetFontDesc :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> FontDescription -> m ()

-- | Sets a custom font map to use for this font chooser widget.
--   
--   A custom font map can be used to present application-specific fonts
--   instead of or in addition to the normal system fonts.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   FcConfig *config;
--   PangoFontMap *fontmap;
--   
--   config = FcInitLoadConfigAndFonts ();
--   FcConfigAppFontAddFile (config, my_app_font_file);
--   
--   fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
--   pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
--   
--   gtk_font_chooser_set_font_map (font_chooser, fontmap);
--   </pre>
--   
--   Note that other GTK widgets will only be able to use the
--   application-specific font if it is present in the font map they use:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   context = gtk_widget_get_pango_context (label);
--   pango_context_set_font_map (context, fontmap);
--   </pre>

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetFontMap :: (HasCallStack, MonadIO m, IsFontChooser a, IsFontMap b) => a -> Maybe b -> m ()

-- | Sets the language to use for font features.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetLanguage :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Sets the desired level of granularity for selecting fonts.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetLevel :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> [FontChooserLevel] -> m ()

-- | Sets the text displayed in the preview area.
--   
--   The <i><tt>text</tt></i> is used to show how the selected font looks.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetPreviewText :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Text -> m ()

-- | Shows or hides the editable preview entry.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a>instead</i>
fontChooserSetShowPreviewEntry :: (HasCallStack, MonadIO m, IsFontChooser a) => a -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontChooserFont :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #font
--   </pre>
getFontChooserFont :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>font</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #font <a>:=</a> value ]
--   </pre>
setFontChooserFont :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>font-desc</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontChooserFontDesc :: (IsFontChooser o, MonadIO m) => FontDescription -> m (GValueConstruct o)

-- | Get the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #fontDesc
--   </pre>
getFontChooserFontDesc :: (MonadIO m, IsFontChooser o) => o -> m (Maybe FontDescription)

-- | Set the value of the “<tt>font-desc</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #fontDesc <a>:=</a> value ]
--   </pre>
setFontChooserFontDesc :: (MonadIO m, IsFontChooser o) => o -> FontDescription -> m ()

-- | Get the value of the “<tt>font-features</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #fontFeatures
--   </pre>
getFontChooserFontFeatures :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>language</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructFontChooserLanguage :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #language
--   </pre>
getFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>language</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #language <a>:=</a> value ]
--   </pre>
setFontChooserLanguage :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>level</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructFontChooserLevel :: (IsFontChooser o, MonadIO m) => [FontChooserLevel] -> m (GValueConstruct o)

-- | Get the value of the “<tt>level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #level
--   </pre>
getFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> m [FontChooserLevel]

-- | Set the value of the “<tt>level</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #level <a>:=</a> value ]
--   </pre>
setFontChooserLevel :: (MonadIO m, IsFontChooser o) => o -> [FontChooserLevel] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>preview-text</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructFontChooserPreviewText :: (IsFontChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>preview-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #previewText
--   </pre>
getFontChooserPreviewText :: (MonadIO m, IsFontChooser o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>preview-text</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #previewText <a>:=</a> value ]
--   </pre>
setFontChooserPreviewText :: (MonadIO m, IsFontChooser o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>show-preview-entry</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructFontChooserShowPreviewEntry :: (IsFontChooser o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>show-preview-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontChooser #showPreviewEntry
--   </pre>
getFontChooserShowPreviewEntry :: (MonadIO m, IsFontChooser o) => o -> m Bool

-- | Set the value of the “<tt>show-preview-entry</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> fontChooser [ #showPreviewEntry <a>:=</a> value ]
--   </pre>
setFontChooserShowPreviewEntry :: (MonadIO m, IsFontChooser o) => o -> Bool -> m ()

-- | Emitted when a font is activated.
--   
--   This usually happens when the user double clicks an item, or an item
--   is selected and the user presses one of the keys Space, Shift+Space,
--   Return or Enter.

-- | <i>Deprecated: (Since version 4.10)Use <a>FontDialog</a> and
--   <a>FontDialogButton</a> instead</i>
type FontChooserFontActivatedCallback = Text -> IO ()

-- | Connect a signal handler for the <a>fontActivated</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> fontChooser #fontActivated callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterFontChooserFontActivated :: (IsFontChooser a, MonadIO m) => a -> ((?self :: a) => FontChooserFontActivatedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>fontActivated</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> fontChooser #fontActivated callback
--   </pre>
onFontChooserFontActivated :: (IsFontChooser a, MonadIO m) => a -> ((?self :: a) => FontChooserFontActivatedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.FontChooser.FontChooser
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.FontChooser.FontChooser
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.FontChooser.FontChooser
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.FontChooser.FontChooser o) => GI.Gtk.Interfaces.FontChooser.IsFontChooser o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.FontChooser.FontChooser)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.FontChooser.FontChooser
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.FontChooser.FontChooser


-- | Interface for single-line text editing widgets.
--   
--   Typical examples of editable widgets are <a>Entry</a> and
--   <a>SpinButton</a>. It contains functions for generically manipulating
--   an editable widget, a large number of action signals used for key
--   bindings, and several signals that an application can connect to
--   modify the behavior of a widget.
--   
--   As an example of the latter usage, by connecting the following handler
--   to <a>Editable::insertText</a>, an application can convert all entry
--   into a widget into uppercase.
--   
--   <h2>Forcing entry to uppercase.</h2>
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   #include &lt;ctype.h&gt;
--   
--   void
--   insert_text_handler (GtkEditable *editable,
--                        const char  *text,
--                        int          length,
--                        int         *position,
--                        gpointer     data)
--   {
--     char *result = g_utf8_strup (text, length);
--   
--     g_signal_handlers_block_by_func (editable,
--                                  (gpointer) insert_text_handler, data);
--     gtk_editable_insert_text (editable, result, length, position);
--     g_signal_handlers_unblock_by_func (editable,
--                                        (gpointer) insert_text_handler, data);
--   
--     g_signal_stop_emission_by_name (editable, "insert_text");
--   
--     g_free (result);
--   }
--   </pre>
--   
--   <h2>Implementing GtkEditable</h2>
--   
--   The most likely scenario for implementing <tt>GtkEditable</tt> on your
--   own widget is that you will embed a <tt>GtkText</tt> inside a complex
--   widget, and want to delegate the editable functionality to that text
--   widget. <tt>GtkEditable</tt> provides some utility functions to make
--   this easy.
--   
--   In your class_init function, call <a>editableInstallProperties</a>,
--   passing the first available property ID:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   my_class_init (MyClass *class)
--   {
--     ...
--     g_object_class_install_properties (object_class, NUM_PROPERTIES, props);
--     gtk_editable_install_properties (object_clas, NUM_PROPERTIES);
--     ...
--   }
--   </pre>
--   
--   In your interface_init function for the <tt>GtkEditable</tt>
--   interface, provide an implementation for the get_delegate vfunc that
--   returns your text widget:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkEditable *
--   get_editable_delegate (GtkEditable *editable)
--   {
--     return GTK_EDITABLE (MY_WIDGET (editable)-&gt;text_widget);
--   }
--   
--   static void
--   my_editable_init (GtkEditableInterface *iface)
--   {
--     iface-&gt;get_delegate = get_editable_delegate;
--   }
--   </pre>
--   
--   You don't need to provide any other vfuncs. The default
--   implementations work by forwarding to the delegate that the
--   GtkEditableInterface.<tt><i>get_delegate()</i></tt> vfunc returns.
--   
--   In your instance_init function, create your text widget, and then call
--   <a>editableInitDelegate</a>:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   my_widget_init (MyWidget *self)
--   {
--     ...
--     self-&gt;text_widget = gtk_text_new ();
--     gtk_editable_init_delegate (GTK_EDITABLE (self));
--     ...
--   }
--   </pre>
--   
--   In your dispose function, call <a>editableFinishDelegate</a> before
--   destroying your text widget:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   my_widget_dispose (GObject *object)
--   {
--     ...
--     gtk_editable_finish_delegate (GTK_EDITABLE (self));
--     g_clear_pointer (&amp;self-&gt;text_widget, gtk_widget_unparent);
--     ...
--   }
--   </pre>
--   
--   Finally, use <a>editableDelegateSetProperty</a> in your
--   <tt>set_property</tt> function (and similar for
--   <tt>get_property</tt>), to set the editable properties:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   ...
--   if (gtk_editable_delegate_set_property (object, prop_id, value, pspec))
--     return;
--   
--   switch (prop_id)
--   ...
--   </pre>
--   
--   It is important to note that if you create a <tt>GtkEditable</tt> that
--   uses a delegate, the low level <a>Editable::insertText</a> and
--   <a>Editable::deleteText</a> signals will be propagated from the
--   "wrapper" editable to the delegate, but they will not be propagated
--   from the delegate to the "wrapper" editable, as they would cause an
--   infinite recursion. If you wish to connect to the
--   <a>Editable::insertText</a> and <a>Editable::deleteText</a> signals,
--   you will need to connect to them on the delegate obtained via
--   <a>editableGetDelegate</a>.
module GI.Gtk.Interfaces.Editable

-- | Memory-managed wrapper type.
newtype Editable
Editable :: ManagedPtr Editable -> Editable

-- | Type class for types which can be safely cast to <a>Editable</a>, for
--   instance with <a>toEditable</a>.
class (GObject o, IsDescendantOf Editable o) => IsEditable o

-- | Cast to <a>Editable</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toEditable :: (MonadIO m, IsEditable o) => o -> m Editable

-- | Retrieves the accessible platform state from the editable delegate.
--   
--   This is an helper function to retrieve the accessible state for
--   <tt>GtkEditable</tt> interface implementations using a delegate
--   pattern.
--   
--   You should call this function in your editable widget implementation
--   of the <a>Accessible</a>.<tt><i>get_platform_state</i></tt>() virtual
--   function, for instance:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   accessible_interface_init (GtkAccessibleInterface *iface)
--   {
--     iface-&gt;get_platform_state = your_editable_get_accessible_platform_state;
--   }
--   
--   static gboolean
--   your_editable_get_accessible_platform_state (GtkAccessible *accessible,
--                                                GtkAccessiblePlatformState state)
--   {
--     return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
--   }
--   </pre>
--   
--   Note that the widget which is the delegate *must* be a direct child of
--   this widget, otherwise your implementation of
--   <a>Accessible</a>.<tt><i>get_platform_state</i></tt>() might not even
--   be called, as the platform change will originate from the parent of
--   the delegate, and, as a result, will not work properly.
--   
--   So, if you can't ensure the direct child condition, you should give
--   the delegate the <a>AccessibleRoleTextBox</a> role, or you can change
--   your tree to allow this function to work.
--   
--   <i>Since: 4.10</i>
editableDelegateGetAccessiblePlatformState :: (HasCallStack, MonadIO m, IsEditable a) => a -> AccessiblePlatformState -> m Bool

-- | Gets a property of the <tt>GtkEditable</tt> delegate for
--   <i><tt>object</tt></i>.
--   
--   This is helper function that should be called in the
--   <tt>get_property</tt> function of your <tt>GtkEditable</tt>
--   implementation, before handling your own properties.
editableDelegateGetProperty :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> GValue -> GParamSpec -> m Bool

-- | Sets a property on the <tt>GtkEditable</tt> delegate for
--   <i><tt>object</tt></i>.
--   
--   This is a helper function that should be called in the
--   <tt>set_property</tt> function of your <tt>GtkEditable</tt>
--   implementation, before handling your own properties.
editableDelegateSetProperty :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> GValue -> GParamSpec -> m Bool

-- | Deletes the currently selected text of the editable.
--   
--   This call doesn’t do anything if there is no selected text.
editableDeleteSelection :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()

-- | Deletes a sequence of characters.
--   
--   The characters that are deleted are those characters at positions from
--   <i><tt>startPos</tt></i> up to, but not including
--   <i><tt>endPos</tt></i>. If <i><tt>endPos</tt></i> is negative, then
--   the characters deleted are those from <i><tt>startPos</tt></i> to the
--   end of the text.
--   
--   Note that the positions are specified in characters, not bytes.
editableDeleteText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()

-- | Undoes the setup done by <a>editableInitDelegate</a>.
--   
--   This is a helper function that should be called from dispose, before
--   removing the delegate object.
editableFinishDelegate :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()

-- | Gets the alignment of the editable.
editableGetAlignment :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Float

-- | Retrieves a sequence of characters.
--   
--   The characters that are retrieved are those characters at positions
--   from <i><tt>startPos</tt></i> up to, but not including
--   <i><tt>endPos</tt></i>. If <i><tt>endPos</tt></i> is negative, then
--   the characters retrieved are those characters from
--   <i><tt>startPos</tt></i> to the end of the text.
--   
--   Note that positions are specified in characters, not bytes.
editableGetChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m Text

-- | Gets the <tt>GtkEditable</tt> that <i><tt>editable</tt></i> is
--   delegating its implementation to.
--   
--   Typically, the delegate is a <a>Text</a> widget.
editableGetDelegate :: (HasCallStack, MonadIO m, IsEditable a) => a -> m (Maybe Editable)

-- | Retrieves whether <i><tt>editable</tt></i> is editable.
editableGetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Bool

-- | Gets if undo/redo actions are enabled for <i><tt>editable</tt></i>
editableGetEnableUndo :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Bool

-- | Retrieves the desired maximum width of <i><tt>editable</tt></i>, in
--   characters.
editableGetMaxWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32

-- | Retrieves the current position of the cursor relative to the start of
--   the content of the editable.
--   
--   Note that this position is in characters, not in bytes.
editableGetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32

-- | Retrieves the selection bound of the editable.
--   
--   <i><tt>startPos</tt></i> will be filled with the start of the
--   selection and <i><tt>endPos</tt></i> with end. If no text was selected
--   both will be identical and <a>False</a> will be returned.
--   
--   Note that positions are specified in characters, not bytes.
editableGetSelectionBounds :: (HasCallStack, MonadIO m, IsEditable a) => a -> m (Bool, Int32, Int32)

-- | Retrieves the contents of <i><tt>editable</tt></i>.
--   
--   The returned string is owned by GTK and must not be modified or freed.
editableGetText :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Text

-- | Gets the number of characters of space reserved for the contents of
--   the editable.
editableGetWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> m Int32

-- | Sets up a delegate for <tt>GtkEditable</tt>.
--   
--   This is assuming that the get_delegate vfunc in the
--   <tt>GtkEditable</tt> interface has been set up for the
--   <i><tt>editable</tt></i>'s type.
--   
--   This is a helper function that should be called in instance init,
--   after creating the delegate object.
editableInitDelegate :: (HasCallStack, MonadIO m, IsEditable a) => a -> m ()

-- | Inserts <i><tt>length</tt></i> bytes of <i><tt>text</tt></i> into the
--   contents of the widget, at position <i><tt>position</tt></i>.
--   
--   Note that the position is in characters, not in bytes. The function
--   updates <i><tt>position</tt></i> to point after the newly inserted
--   text.
editableInsertText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> Int32 -> Int32 -> m Int32

-- | Overrides the <tt>GtkEditable</tt> properties for
--   <i><tt>class</tt></i>.
--   
--   This is a helper function that should be called in class_init, after
--   installing your own properties.
--   
--   Note that your class must have "text", "cursor-position",
--   "selection-bound", "editable", "width-chars", "max-width-chars",
--   "xalign" and "enable-undo" properties for this function to work.
--   
--   To handle the properties in your set_property and get_property
--   functions, you can either use <a>editableDelegateSetProperty</a> and
--   <a>editableDelegateGetProperty</a> (if you are using a delegate), or
--   remember the <i><tt>firstProp</tt></i> offset and add it to the values
--   in the <a>EditableProperties</a> enumeration to get the property IDs
--   for these properties.
editableInstallProperties :: (HasCallStack, MonadIO m) => ObjectClass -> Word32 -> m Word32

-- | Selects a region of text.
--   
--   The characters that are selected are those characters at positions
--   from <i><tt>startPos</tt></i> up to, but not including
--   <i><tt>endPos</tt></i>. If <i><tt>endPos</tt></i> is negative, then
--   the characters selected are those characters from
--   <i><tt>startPos</tt></i> to the end of the text.
--   
--   Note that positions are specified in characters, not bytes.
editableSelectRegion :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> Int32 -> m ()

-- | Sets the alignment for the contents of the editable.
--   
--   This controls the horizontal positioning of the contents when the
--   displayed text is shorter than the width of the editable.
editableSetAlignment :: (HasCallStack, MonadIO m, IsEditable a) => a -> Float -> m ()

-- | Determines if the user can edit the text in the editable widget.
editableSetEditable :: (HasCallStack, MonadIO m, IsEditable a) => a -> Bool -> m ()

-- | If enabled, changes to <i><tt>editable</tt></i> will be saved for
--   undo/redo actions.
--   
--   This results in an additional copy of text changes and are not stored
--   in secure memory. As such, undo is forcefully disabled when
--   <a>Text:visibility</a> is set to <a>False</a>.
editableSetEnableUndo :: (HasCallStack, MonadIO m, IsEditable a) => a -> Bool -> m ()

-- | Sets the desired maximum width in characters of
--   <i><tt>editable</tt></i>.
editableSetMaxWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()

-- | Sets the cursor position in the editable to the given value.
--   
--   The cursor is displayed before the character with the given (base 0)
--   index in the contents of the editable. The value must be less than or
--   equal to the number of characters in the editable. A value of -1
--   indicates that the position should be set after the last character of
--   the editable. Note that <i><tt>position</tt></i> is in characters, not
--   in bytes.
editableSetPosition :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()

-- | Sets the text in the editable to the given value.
--   
--   This is replacing the current contents.
editableSetText :: (HasCallStack, MonadIO m, IsEditable a) => a -> Text -> m ()

-- | Changes the size request of the editable to be about the right size
--   for <i><tt>nChars</tt></i> characters.
--   
--   Note that it changes the size request, the size can still be affected
--   by how you pack the widget into containers. If <i><tt>nChars</tt></i>
--   is -1, the size reverts to the default size.
editableSetWidthChars :: (HasCallStack, MonadIO m, IsEditable a) => a -> Int32 -> m ()

-- | Get the value of the “<tt>cursor-position</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #cursorPosition
--   </pre>
getEditableCursorPosition :: (MonadIO m, IsEditable o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editable</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructEditableEditable :: (IsEditable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #editable
--   </pre>
getEditableEditable :: (MonadIO m, IsEditable o) => o -> m Bool

-- | Set the value of the “<tt>editable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> editable [ #editable <a>:=</a> value ]
--   </pre>
setEditableEditable :: (MonadIO m, IsEditable o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>enable-undo</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEditableEnableUndo :: (IsEditable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>enable-undo</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #enableUndo
--   </pre>
getEditableEnableUndo :: (MonadIO m, IsEditable o) => o -> m Bool

-- | Set the value of the “<tt>enable-undo</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> editable [ #enableUndo <a>:=</a> value ]
--   </pre>
setEditableEnableUndo :: (MonadIO m, IsEditable o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>max-width-chars</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructEditableMaxWidthChars :: (IsEditable o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #maxWidthChars
--   </pre>
getEditableMaxWidthChars :: (MonadIO m, IsEditable o) => o -> m Int32

-- | Set the value of the “<tt>max-width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> editable [ #maxWidthChars <a>:=</a> value ]
--   </pre>
setEditableMaxWidthChars :: (MonadIO m, IsEditable o) => o -> Int32 -> m ()

-- | Get the value of the “<tt>selection-bound</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #selectionBound
--   </pre>
getEditableSelectionBound :: (MonadIO m, IsEditable o) => o -> m Int32

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>text</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEditableText :: (IsEditable o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #text
--   </pre>
getEditableText :: (MonadIO m, IsEditable o) => o -> m Text

-- | Set the value of the “<tt>text</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> editable [ #text <a>:=</a> value ]
--   </pre>
setEditableText :: (MonadIO m, IsEditable o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>width-chars</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructEditableWidthChars :: (IsEditable o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #widthChars
--   </pre>
getEditableWidthChars :: (MonadIO m, IsEditable o) => o -> m Int32

-- | Set the value of the “<tt>width-chars</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> editable [ #widthChars <a>:=</a> value ]
--   </pre>
setEditableWidthChars :: (MonadIO m, IsEditable o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>xalign</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructEditableXalign :: (IsEditable o, MonadIO m) => Float -> m (GValueConstruct o)

-- | Get the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> editable #xalign
--   </pre>
getEditableXalign :: (MonadIO m, IsEditable o) => o -> m Float

-- | Set the value of the “<tt>xalign</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> editable [ #xalign <a>:=</a> value ]
--   </pre>
setEditableXalign :: (MonadIO m, IsEditable o) => o -> Float -> m ()

-- | Emitted at the end of a single user-visible operation on the contents.
--   
--   E.g., a paste operation that replaces the contents of the selection
--   will cause only one signal emission (even though it is implemented by
--   first deleting the selection, then inserting the new content, and may
--   cause multiple <a>notify</a><a>text</a> signals to be emitted).
type EditableChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> editable #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> editable #changed callback
--   </pre>
onEditableChanged :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableChangedCallback) -> m SignalHandlerId

-- | Emitted when text is deleted from the widget by the user.
--   
--   The default handler for this signal will normally be responsible for
--   deleting the text, so by connecting to this signal and then stopping
--   the signal with <a>signalStopEmission</a>, it is possible to modify
--   the range of deleted text, or prevent it from being deleted entirely.
--   
--   The <i><tt>startPos</tt></i> and <i><tt>endPos</tt></i> parameters are
--   interpreted as for <a>editableDeleteText</a>.
type EditableDeleteTextCallback = Int32 -> Int32 -> IO ()

-- | Connect a signal handler for the <a>deleteText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> editable #deleteText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEditableDeleteText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableDeleteTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>deleteText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> editable #deleteText callback
--   </pre>
onEditableDeleteText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableDeleteTextCallback) -> m SignalHandlerId

-- | Emitted when text is inserted into the widget by the user.
--   
--   The default handler for this signal will normally be responsible for
--   inserting the text, so by connecting to this signal and then stopping
--   the signal with <a>signalStopEmission</a>, it is possible to modify
--   the inserted text, or prevent it from being inserted entirely.
type EditableInsertTextCallback = Text -> Int32 -> Int32 -> IO Int32

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> editable #insertText callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterEditableInsertText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableInsertTextCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>insertText</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> editable #insertText callback
--   </pre>
onEditableInsertText :: (IsEditable a, MonadIO m) => a -> ((?self :: a) => EditableInsertTextCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.Editable.Editable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Editable.Editable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Editable.Editable
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Editable.Editable o) => GI.Gtk.Interfaces.Editable.IsEditable o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Editable.Editable)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Editable.Editable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Editable.Editable


-- | An interface for packing cells
--   
--   <tt>GtkCellLayout</tt> is an interface to be implemented by all
--   objects which want to provide a <tt>GtkTreeViewColumn</tt> like API
--   for packing cells, setting attributes and data funcs.
--   
--   One of the notable features provided by implementations of
--   <tt>GtkCellLayout</tt> are attributes. Attributes let you set the
--   properties in flexible ways. They can just be set to constant values
--   like regular properties. But they can also be mapped to a column of
--   the underlying tree model with
--   <tt><i>gtk_cell_layout_set_attributes()</i></tt>, which means that the
--   value of the attribute can change from cell to cell as they are
--   rendered by the cell renderer. Finally, it is possible to specify a
--   function with <a>cellLayoutSetCellDataFunc</a> that is called to
--   determine the value of the attribute for each cell that is rendered.
--   
--   <h2>GtkCellLayouts as GtkBuildable</h2>
--   
--   Implementations of GtkCellLayout which also implement the GtkBuildable
--   interface (<tt>GtkCellView</tt>, <tt>GtkIconView</tt>,
--   <tt>GtkComboBox</tt>, <tt>GtkEntryCompletion</tt>,
--   <tt>GtkTreeViewColumn</tt>) accept <tt>GtkCellRenderer</tt> objects as
--   <tt>&lt;child&gt;</tt> elements in UI definitions. They support a
--   custom <tt>&lt;attributes&gt;</tt> element for their children, which
--   can contain multiple <tt>&lt;attribute&gt;</tt> elements. Each
--   <tt>&lt;attribute&gt;</tt> element has a name attribute which
--   specifies a property of the cell renderer; the content of the element
--   is the attribute value.
--   
--   This is an example of a UI definition fragment specifying attributes:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkCellView"&gt;
--     &lt;child&gt;
--       &lt;object class="GtkCellRendererText"/&gt;
--       &lt;attributes&gt;
--         &lt;attribute name="text"&gt;0&lt;/attribute&gt;
--       &lt;/attributes&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   Furthermore for implementations of <tt>GtkCellLayout</tt> that use a
--   <tt>GtkCellArea</tt> to lay out cells (all <tt>GtkCellLayout</tt>s in
--   GTK use a <tt>GtkCellArea</tt>) <a>cell properties</a> can also be
--   defined in the format by specifying the custom
--   <tt>&lt;cell-packing&gt;</tt> attribute which can contain multiple
--   <tt>&lt;property&gt;</tt> elements.
--   
--   Here is a UI definition fragment specifying cell properties:
--   
--   <h3><i>xml code</i></h3>
--   
--   <pre>
--   &lt;object class="GtkTreeViewColumn"&gt;
--     &lt;child&gt;
--       &lt;object class="GtkCellRendererText"/&gt;
--       &lt;cell-packing&gt;
--         &lt;property name="align"&gt;True&lt;/property&gt;
--         &lt;property name="expand"&gt;False&lt;/property&gt;
--       &lt;/cell-packing&gt;
--     &lt;/child&gt;
--   &lt;/object&gt;
--   </pre>
--   
--   <h2>Subclassing GtkCellLayout implementations</h2>
--   
--   When subclassing a widget that implements <tt>GtkCellLayout</tt> like
--   <tt>GtkIconView</tt> or <tt>GtkComboBox</tt>, there are some
--   considerations related to the fact that these widgets internally use a
--   <tt>GtkCellArea</tt>. The cell area is exposed as a construct-only
--   property by these widgets. This means that it is possible to e.g. do
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GtkWIdget *combo =
--     g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL);
--   </pre>
--   
--   to use a custom cell area with a combo box. But construct properties
--   are only initialized after instance <tt>init()</tt> functions have
--   run, which means that using functions which rely on the existence of
--   the cell area in your subclass <tt>init()</tt> function will cause the
--   default cell area to be instantiated. In this case, a provided
--   construct property value will be ignored (with a warning, to alert you
--   to the problem).
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   static void
--   my_combo_box_init (MyComboBox *b)
--   {
--     GtkCellRenderer *cell;
--   
--     cell = gtk_cell_renderer_pixbuf_new ();
--   
--     // The following call causes the default cell area for combo boxes,
--     // a GtkCellAreaBox, to be instantiated
--     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE);
--     ...
--   }
--   
--   GtkWidget *
--   my_combo_box_new (GtkCellArea *area)
--   {
--     // This call is going to cause a warning about area being ignored
--     return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL);
--   }
--   </pre>
--   
--   If supporting alternative cell areas with your derived widget is not
--   important, then this does not have to concern you. If you want to
--   support alternative cell areas, you can do so by moving the
--   problematic calls out of <tt>init()</tt> and into a
--   <tt>constructor()</tt> for your class.
module GI.Gtk.Interfaces.CellLayout

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)List views use widgets to display
--   their contents.See <a>LayoutManager</a> for layout manager delegate
--   objects</i>
newtype CellLayout

-- | <i>Deprecated: (Since version 4.10)List views use widgets to display
--   their contents.See <a>LayoutManager</a> for layout manager delegate
--   objects</i>
CellLayout :: ManagedPtr CellLayout -> CellLayout

-- | Type class for types which can be safely cast to <a>CellLayout</a>,
--   for instance with <a>toCellLayout</a>.
class (GObject o, IsDescendantOf CellLayout o) => IsCellLayout o

-- | Cast to <a>CellLayout</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellLayout :: (MonadIO m, IsCellLayout o) => o -> m CellLayout

-- | Adds an attribute mapping to the list in <i><tt>cellLayout</tt></i>.
--   
--   The <i><tt>column</tt></i> is the column of the model to get a value
--   from, and the <i><tt>attribute</tt></i> is the property on
--   <i><tt>cell</tt></i> to be set from that value. So for example if
--   column 2 of the model contains strings, you could have the “text”
--   attribute of a <tt>GtkCellRendererText</tt> get its values from column
--   2. In this context "attribute" and "property" are used
--   interchangeably.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutAddAttribute :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Text -> Int32 -> m ()

-- | Unsets all the mappings on all renderers on <i><tt>cellLayout</tt></i>
--   and removes all renderers from <i><tt>cellLayout</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutClear :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m ()

-- | Clears all existing attributes previously set with
--   <tt><i>gtk_cell_layout_set_attributes()</i></tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutClearAttributes :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> m ()

-- | Returns the underlying <tt>GtkCellArea</tt> which might be
--   <i><tt>cellLayout</tt></i> if called on a <tt>GtkCellArea</tt> or
--   might be <a>Nothing</a> if no <tt>GtkCellArea</tt> is used by
--   <i><tt>cellLayout</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutGetArea :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m (Maybe CellArea)

-- | Returns the cell renderers which have been added to
--   <i><tt>cellLayout</tt></i>.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutGetCells :: (HasCallStack, MonadIO m, IsCellLayout a) => a -> m [CellRenderer]

-- | Adds the <i><tt>cell</tt></i> to the end of
--   <i><tt>cellLayout</tt></i>. If <i><tt>expand</tt></i> is <a>False</a>,
--   then the <i><tt>cell</tt></i> is allocated no more space than it
--   needs. Any unused space is divided evenly between cells for which
--   <i><tt>expand</tt></i> is <a>True</a>.
--   
--   Note that reusing the same cell renderer is not supported.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutPackEnd :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Packs the <i><tt>cell</tt></i> into the beginning of
--   <i><tt>cellLayout</tt></i>. If <i><tt>expand</tt></i> is <a>False</a>,
--   then the <i><tt>cell</tt></i> is allocated no more space than it
--   needs. Any unused space is divided evenly between cells for which
--   <i><tt>expand</tt></i> is <a>True</a>.
--   
--   Note that reusing the same cell renderer is not supported.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutPackStart :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Bool -> m ()

-- | Re-inserts <i><tt>cell</tt></i> at <i><tt>position</tt></i>.
--   
--   Note that <i><tt>cell</tt></i> has already to be packed into
--   <i><tt>cellLayout</tt></i> for this to function properly.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutReorder :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Int32 -> m ()

-- | Sets the <tt>GtkCellLayout</tt>DataFunc to use for
--   <i><tt>cellLayout</tt></i>.
--   
--   This function is used instead of the standard attributes mapping for
--   setting the column value, and should set the value of
--   <i><tt>cellLayout</tt></i>’s cell renderer(s) as appropriate.
--   
--   <i><tt>func</tt></i> may be <a>Nothing</a> to remove a previously set
--   function.

-- | <i>Deprecated: (Since version 4.10)</i>
cellLayoutSetCellDataFunc :: (HasCallStack, MonadIO m, IsCellLayout a, IsCellRenderer b) => a -> b -> Maybe CellLayoutDataFunc -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.CellLayout.CellLayout
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.CellLayout.CellLayout
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.CellLayout.CellLayout
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.CellLayout.CellLayout o) => GI.Gtk.Interfaces.CellLayout.IsCellLayout o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.CellLayout.CellLayout)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.CellLayout.CellLayout
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.CellLayout.CellLayout


-- | Interface for widgets that can be used for editing cells
--   
--   The <tt>GtkCellEditable</tt> interface must be implemented for widgets
--   to be usable to edit the contents of a <tt>GtkTreeView</tt> cell. It
--   provides a way to specify how temporary widgets should be configured
--   for editing, get the new value, etc.
module GI.Gtk.Interfaces.CellEditable

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)List views use widgets for
--   displaying theircontents. See <a>Editable</a> for editable text
--   widgets</i>
newtype CellEditable

-- | <i>Deprecated: (Since version 4.10)List views use widgets for
--   displaying theircontents. See <a>Editable</a> for editable text
--   widgets</i>
CellEditable :: ManagedPtr CellEditable -> CellEditable

-- | Type class for types which can be safely cast to <a>CellEditable</a>,
--   for instance with <a>toCellEditable</a>.
class (GObject o, IsDescendantOf CellEditable o) => IsCellEditable o

-- | Cast to <a>CellEditable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCellEditable :: (MonadIO m, IsCellEditable o) => o -> m CellEditable

-- | Emits the <tt>GtkCellEditable::editing-done</tt> signal.

-- | <i>Deprecated: (Since version 4.10)</i>
cellEditableEditingDone :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> m ()

-- | Emits the <tt>GtkCellEditable::remove-widget</tt> signal.

-- | <i>Deprecated: (Since version 4.10)</i>
cellEditableRemoveWidget :: (HasCallStack, MonadIO m, IsCellEditable a) => a -> m ()

-- | Begins editing on a <i><tt>cellEditable</tt></i>.
--   
--   The <tt>GtkCellRenderer</tt> for the cell creates and returns a
--   <tt>GtkCellEditable</tt> from <a>cellRendererStartEditing</a>,
--   configured for the <tt>GtkCellRenderer</tt> type.
--   
--   <a>cellEditableStartEditing</a> can then set up
--   <i><tt>cellEditable</tt></i> suitably for editing a cell, e.g. making
--   the Esc key emit <tt>GtkCellEditable::editing-done</tt>.
--   
--   Note that the <i><tt>cellEditable</tt></i> is created on-demand for
--   the current edit; its lifetime is temporary and does not persist
--   across other edits and/or cells.
cellEditableStartEditing :: (HasCallStack, MonadIO m, IsCellEditable a, IsEvent b) => a -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>editing-canceled</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCellEditableEditingCanceled :: (IsCellEditable o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>editing-canceled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cellEditable #editingCanceled
--   </pre>
getCellEditableEditingCanceled :: (MonadIO m, IsCellEditable o) => o -> m Bool

-- | Set the value of the “<tt>editing-canceled</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cellEditable [ #editingCanceled <a>:=</a> value ]
--   </pre>
setCellEditableEditingCanceled :: (MonadIO m, IsCellEditable o) => o -> Bool -> m ()

-- | This signal is a sign for the cell renderer to update its value from
--   the <i><tt>cellEditable</tt></i>.
--   
--   Implementations of <tt>GtkCellEditable</tt> are responsible for
--   emitting this signal when they are done editing, e.g.
--   <tt>GtkEntry</tt> emits this signal when the user presses Enter.
--   Typical things to do in a handler for <a>editingDone</a> are to
--   capture the edited value, disconnect the <i><tt>cellEditable</tt></i>
--   from signals on the <tt>GtkCellRenderer</tt>, etc.
--   
--   <a>cellEditableEditingDone</a> is a convenience method for emitting
--   <tt>GtkCellEditable::editing-done</tt>.
type CellEditableEditingDoneCallback = IO ()

-- | Connect a signal handler for the <a>editingDone</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellEditable #editingDone callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellEditableEditingDone :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableEditingDoneCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>editingDone</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellEditable #editingDone callback
--   </pre>
onCellEditableEditingDone :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableEditingDoneCallback) -> m SignalHandlerId

-- | This signal is meant to indicate that the cell is finished editing,
--   and the <i><tt>cellEditable</tt></i> widget is being removed and may
--   subsequently be destroyed.
--   
--   Implementations of <tt>GtkCellEditable</tt> are responsible for
--   emitting this signal when they are done editing. It must be emitted
--   after the <tt>GtkCellEditable::editing-done</tt> signal, to give the
--   cell renderer a chance to update the cell's value before the widget is
--   removed.
--   
--   <a>cellEditableRemoveWidget</a> is a convenience method for emitting
--   <tt>GtkCellEditable::remove-widget</tt>.
type CellEditableRemoveWidgetCallback = IO ()

-- | Connect a signal handler for the <a>removeWidget</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> cellEditable #removeWidget callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterCellEditableRemoveWidget :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableRemoveWidgetCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>removeWidget</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> cellEditable #removeWidget callback
--   </pre>
onCellEditableRemoveWidget :: (IsCellEditable a, MonadIO m) => a -> ((?self :: a) => CellEditableRemoveWidgetCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.Gtk.Interfaces.CellEditable.CellEditable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.CellEditable.CellEditable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.CellEditable.CellEditable
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.CellEditable.CellEditable o) => GI.Gtk.Interfaces.CellEditable.IsCellEditable o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.CellEditable.CellEditable)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.CellEditable.CellEditable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.CellEditable.CellEditable


-- | <tt>GtkAppChooser</tt> is an interface for widgets which allow the
--   user to choose an application.
--   
--   The main objects that implement this interface are
--   <a>AppChooserWidget</a>, <a>AppChooserDialog</a> and
--   <a>AppChooserButton</a>.
--   
--   Applications are represented by GIO <tt>GAppInfo</tt> objects here.
--   GIO has a concept of recommended and fallback applications for a given
--   content type. Recommended applications are those that claim to handle
--   the content type itself, while fallback also includes applications
--   that handle a more generic content type. GIO also knows the default
--   and last-used application for a given content type. The
--   <tt>GtkAppChooserWidget</tt> provides detailed control over whether
--   the shown list of applications should include default, recommended or
--   fallback applications.
--   
--   To obtain the application that has been selected in a
--   <tt>GtkAppChooser</tt>, use <a>appChooserGetAppInfo</a>.
module GI.Gtk.Interfaces.AppChooser

-- | Memory-managed wrapper type.

-- | <i>Deprecated: (Since version 4.10)The application selection widgets
--   should beimplemented according to the design of each platform
--   and/orapplication requiring them.</i>
newtype AppChooser

-- | <i>Deprecated: (Since version 4.10)The application selection widgets
--   should beimplemented according to the design of each platform
--   and/orapplication requiring them.</i>
AppChooser :: ManagedPtr AppChooser -> AppChooser

-- | Type class for types which can be safely cast to <a>AppChooser</a>,
--   for instance with <a>toAppChooser</a>.
class (GObject o, IsDescendantOf AppChooser o) => IsAppChooser o

-- | Cast to <a>AppChooser</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAppChooser :: (MonadIO m, IsAppChooser o) => o -> m AppChooser

-- | Returns the currently selected application.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserGetAppInfo :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m (Maybe AppInfo)

-- | Returns the content type for which the <tt>GtkAppChooser</tt> shows
--   applications.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserGetContentType :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m Text

-- | Reloads the list of applications.

-- | <i>Deprecated: (Since version 4.10)This widget will be removed in GTK
--   5</i>
appChooserRefresh :: (HasCallStack, MonadIO m, IsAppChooser a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>content-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructAppChooserContentType :: (IsAppChooser o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>content-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> appChooser #contentType
--   </pre>
getAppChooserContentType :: (MonadIO m, IsAppChooser o) => o -> m (Maybe Text)
instance GHC.Classes.Eq GI.Gtk.Interfaces.AppChooser.AppChooser
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.AppChooser.AppChooser
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.AppChooser.AppChooser
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.AppChooser.AppChooser o) => GI.Gtk.Interfaces.AppChooser.IsAppChooser o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.AppChooser.AppChooser)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.AppChooser.AppChooser
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.AppChooser.AppChooser


-- | Provides a way to associate widgets with actions.
--   
--   It primarily consists of two properties: <a>Actionable:actionName</a>
--   and <a>Actionable:actionTarget</a>. There are also some convenience
--   APIs for setting these properties.
--   
--   The action will be looked up in action groups that are found among the
--   widgets ancestors. Most commonly, these will be the actions with the
--   “win.” or “app.” prefix that are associated with the
--   <tt>GtkApplicationWindow</tt> or <tt>GtkApplication</tt>, but other
--   action groups that are added with <a>widgetInsertActionGroup</a> will
--   be consulted as well.
module GI.Gtk.Interfaces.Actionable

-- | Memory-managed wrapper type.
newtype Actionable
Actionable :: ManagedPtr Actionable -> Actionable

-- | Type class for types which can be safely cast to <a>Actionable</a>,
--   for instance with <a>toActionable</a>.
class (GObject o, IsDescendantOf Actionable o) => IsActionable o

-- | Cast to <a>Actionable</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toActionable :: (MonadIO m, IsActionable o) => o -> m Actionable

-- | Gets the action name for <i><tt>actionable</tt></i>.
actionableGetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> m (Maybe Text)

-- | Gets the current target value of <i><tt>actionable</tt></i>.
actionableGetActionTargetValue :: (HasCallStack, MonadIO m, IsActionable a) => a -> m (Maybe GVariant)

-- | Specifies the name of the action with which this widget should be
--   associated.
--   
--   If <i><tt>actionName</tt></i> is <a>Nothing</a> then the widget will
--   be unassociated from any previous action.
--   
--   Usually this function is used when the widget is located (or will be
--   located) within the hierarchy of a <tt>GtkApplicationWindow</tt>.
--   
--   Names are of the form “win.save” or “app.quit” for actions on the
--   containing [class<i><tt>applicationWindow</tt></i>] or its associated
--   [class<i><tt>application</tt></i>], respectively. This is the same
--   form used for actions in the <a>Menu</a> associated with the window.
actionableSetActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe Text -> m ()

-- | Sets the target value of an actionable widget.
--   
--   If <i><tt>targetValue</tt></i> is <a>Nothing</a> then the target value
--   is unset.
--   
--   The target value has two purposes. First, it is used as the parameter
--   to activation of the action associated with the <tt>GtkActionable</tt>
--   widget. Second, it is used to determine if the widget should be
--   rendered as “active” — the widget is active if the state is equal to
--   the given target.
--   
--   Consider the example of associating a set of buttons with a
--   <a>Action</a> with string state in a typical “radio button” situation.
--   Each button will be associated with the same action, but with a
--   different target value for that action. Clicking on a particular
--   button will activate the action with the target of that button, which
--   will typically cause the action’s state to change to that value. Since
--   the action’s state is now equal to the target value of the button, the
--   button will now be rendered as active (and the other buttons, with
--   different targets, rendered inactive).
actionableSetActionTargetValue :: (HasCallStack, MonadIO m, IsActionable a) => a -> Maybe GVariant -> m ()

-- | Sets the action-name and associated string target value of an
--   actionable widget.
--   
--   <i><tt>detailedActionName</tt></i> is a string in the format accepted
--   by <a>actionParseDetailedName</a>.
actionableSetDetailedActionName :: (HasCallStack, MonadIO m, IsActionable a) => a -> Text -> m ()

-- | Set the value of the “<tt>action-name</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #actionName
--   </pre>
clearActionableActionName :: (MonadIO m, IsActionable o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-name</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionableActionName :: (IsActionable o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionable #actionName
--   </pre>
getActionableActionName :: (MonadIO m, IsActionable o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>action-name</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionable [ #actionName <a>:=</a> value ]
--   </pre>
setActionableActionName :: (MonadIO m, IsActionable o) => o -> Text -> m ()

-- | Set the value of the “<tt>action-target</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #actionTarget
--   </pre>
clearActionableActionTarget :: (MonadIO m, IsActionable o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>action-target</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructActionableActionTarget :: (IsActionable o, MonadIO m) => GVariant -> m (GValueConstruct o)

-- | Get the value of the “<tt>action-target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> actionable #actionTarget
--   </pre>
getActionableActionTarget :: (MonadIO m, IsActionable o) => o -> m (Maybe GVariant)

-- | Set the value of the “<tt>action-target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> actionable [ #actionTarget <a>:=</a> value ]
--   </pre>
setActionableActionTarget :: (MonadIO m, IsActionable o) => o -> GVariant -> m ()
instance GHC.Classes.Eq GI.Gtk.Interfaces.Actionable.Actionable
instance Data.GI.Base.BasicTypes.GObject GI.Gtk.Interfaces.Actionable.Actionable
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Interfaces.Actionable.Actionable
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gtk.Interfaces.Actionable.Actionable o) => GI.Gtk.Interfaces.Actionable.IsActionable o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Interfaces.Actionable.Actionable)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Interfaces.Actionable.Actionable
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Interfaces.Actionable.Actionable


module GI.Gtk.Interfaces


module GI.Gtk.Functions

-- | Generates an accessible description of an accelerator.
--   
--   This function is similar to <a>acceleratorGetLabel</a> but it is meant
--   for accessibility layers labels rather than user-facing labels. The
--   output of this function is fit for
--   <a>AccessiblePropertyKeyShortcuts</a>.
--   
--   For more information, see the <a>WAI-ARIA</a> reference.
--   
--   <i>Since: 4.22</i>
acceleratorGetAccessibleLabel :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text

-- | Gets the modifier mask.
--   
--   The modifier mask determines which modifiers are considered
--   significant for keyboard accelerators. This includes all keyboard
--   modifiers except for <tt>GDK_LOCK_MASK</tt>.
acceleratorGetDefaultModMask :: (HasCallStack, MonadIO m) => m [ModifierType]

-- | Converts an accelerator keyval and modifier mask into a string which
--   can be used to represent the accelerator to the user.
acceleratorGetLabel :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text

-- | Converts an accelerator keyval and modifier mask into a string that
--   can be displayed to the user.
--   
--   The string may be translated.
--   
--   This function is similar to <a>acceleratorGetLabel</a>, but handling
--   keycodes. This is only useful for system-level components,
--   applications should use <a>acceleratorGetLabel</a> instead.
acceleratorGetLabelWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text

-- | Converts an accelerator keyval and modifier mask into a string that
--   can be parsed by <a>acceleratorParse</a>.
--   
--   For example, if you pass in <tt>GDK_KEY_q</tt> and
--   <tt>GDK_CONTROL_MASK</tt>, this function returns
--   <tt>&lt;Control&gt;q</tt>.
--   
--   If you need to display accelerators in the user interface, see
--   <a>acceleratorGetLabel</a>.
acceleratorName :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text

-- | Converts an accelerator keyval and modifier mask into a string that
--   can be parsed by <a>acceleratorParseWithKeycode</a>.
--   
--   This is similar to <a>acceleratorName</a> but handling keycodes. This
--   is only useful for system-level components, applications should use
--   <a>acceleratorName</a> instead.
acceleratorNameWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text

-- | Parses a string representing an accelerator.
--   
--   The format looks like “<tt>&lt;Control&gt;a</tt>” or
--   “<tt>&lt;Shift&gt;&lt;Alt&gt;F1</tt>”.
--   
--   The parser is fairly liberal and allows lower or upper case, and also
--   abbreviations such as “<tt>&lt;Ctl&gt;</tt>” and
--   “<tt>&lt;Ctrl&gt;</tt>”.
--   
--   Key names are parsed using <a>keyvalFromName</a>. For character keys
--   the name is not the symbol, but the lowercase name, e.g. one would use
--   “<tt>&lt;Ctrl&gt;minus</tt>” instead of “<tt>&lt;Ctrl&gt;-</tt>”.
--   
--   Modifiers are enclosed in angular brackets <tt>&lt;&gt;</tt>, and
--   match the [flags<i><tt>gdk</tt></i>.ModifierType] mask:
--   
--   <ul>
--   <li><tt>&lt;Shift&gt;</tt> for <tt>GDK_SHIFT_MASK</tt></li>
--   <li><tt>&lt;Ctrl&gt;</tt> for <tt>GDK_CONTROL_MASK</tt></li>
--   <li><tt>&lt;Alt&gt;</tt> for <tt>GDK_ALT_MASK</tt></li>
--   <li><tt>&lt;Meta&gt;</tt> for <tt>GDK_META_MASK</tt></li>
--   <li><tt>&lt;Super&gt;</tt> for <tt>GDK_SUPER_MASK</tt></li>
--   <li><tt>&lt;Hyper&gt;</tt> for <tt>GDK_HYPER_MASK</tt></li>
--   </ul>
--   
--   If the parse operation fails, <i><tt>acceleratorKey</tt></i> and
--   <i><tt>acceleratorMods</tt></i> will be set to 0 (zero).
acceleratorParse :: (HasCallStack, MonadIO m) => Text -> m (Bool, Word32, [ModifierType])

-- | Parses a string representing an accelerator.
--   
--   This is similar to <a>acceleratorParse</a> but handles keycodes as
--   well. This is only useful for system-level components, applications
--   should use <a>acceleratorParse</a> instead.
--   
--   If <i><tt>acceleratorCodes</tt></i> is given and the result stored in
--   it is non-<a>Nothing</a>, the result must be freed with <a>free</a>.
--   
--   If a keycode is present in the accelerator and no
--   <i><tt>acceleratorCodes</tt></i> is given, the parse will fail.
--   
--   If the parse fails, <i><tt>acceleratorKey</tt></i>,
--   <i><tt>acceleratorMods</tt></i> and <i><tt>acceleratorCodes</tt></i>
--   will be set to 0 (zero).
acceleratorParseWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Text -> Maybe a -> m (Bool, Word32, [Word32], [ModifierType])

-- | Determines whether a given keyval and modifier mask constitute a valid
--   keyboard accelerator.
--   
--   For example, the <tt>GDK_KEY_a</tt> keyval plus
--   <tt>GDK_CONTROL_MASK</tt> mask is valid, and matches the “Ctrl+a”
--   accelerator. But, you can't, for instance, use the
--   <tt>GDK_KEY_Control_L</tt> keyval as an accelerator.
acceleratorValid :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Bool

-- | Checks that the GTK library in use is compatible with the given
--   version.
--   
--   Generally you would pass in the constants <a>MAJOR_VERSION</a>,
--   <a>MINOR_VERSION</a>, <a>MICRO_VERSION</a> as the three arguments to
--   this function; that produces a check that the library in use is
--   compatible with the version of GTK the application or module was
--   compiled against.
--   
--   Compatibility is defined by two things: first the version of the
--   running library is newer than the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>.
--   Second the running library must be binary compatible with the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>
--   (same major version.)
--   
--   This function is primarily for GTK modules; the module can call this
--   function to check that it wasn’t loaded into an incompatible version
--   of GTK. However, such a check isn’t completely reliable, since the
--   module may be linked against an old version of GTK and calling the old
--   version of <a>checkVersion</a>, but still get loaded into an
--   application using a newer version of GTK.
checkVersion :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> Word32 -> m (Maybe Text)

-- | Registers an error quark for CSS parsing errors.
cssParserErrorQuark :: (HasCallStack, MonadIO m) => m Word32

-- | Registers an error quark for CSS parsing warnings.
cssParserWarningQuark :: (HasCallStack, MonadIO m) => m Word32

-- | Prevents GTK from using the specified portals.
--   
--   This should only be used in portal implementations, apps must not call
--   it.
--   
--   <i>Since: 4.22</i>
disablePortalInterfaces :: (HasCallStack, MonadIO m) => [Text] -> m ()

-- | Prevents GTK from using portals.
--   
--   This is equivalent to setting <tt>GDK_DEBUG=no-portals</tt> in the
--   environment.
--   
--   This should only be used in portal implementations, apps must not call
--   it.
--   
--   <i>Since: 4.18</i>
disablePortals :: (HasCallStack, MonadIO m) => m ()

-- | Prevents <a>init</a> and <a>initCheck</a> from calling
--   <tt>setlocale()</tt>.
--   
--   You would want to use this function if you wanted to set the locale
--   for your program to something other than the user’s locale, or if you
--   wanted to set different values for different locale categories.
--   
--   Most programs should not need to call this function.
disableSetlocale :: (HasCallStack, MonadIO m) => m ()

-- | Distributes <i><tt>extraSpace</tt></i> to child <i><tt>sizes</tt></i>
--   by bringing smaller children up to natural size first.
--   
--   The remaining space will be added to the <i><tt>minimumSize</tt></i>
--   member of the <tt>GtkRequestedSize</tt> struct. If all sizes reach
--   their natural size then the remaining space is returned.
distributeNaturalAllocation :: (HasCallStack, MonadIO m) => Int32 -> [RequestedSize] -> m Int32

-- | Calls a function for all printers that are known to GTK.
--   
--   If <i><tt>func</tt></i> returns true, the enumeration is stopped.
enumeratePrinters :: (HasCallStack, MonadIO m) => PrinterFunc -> Bool -> m ()

-- | Returns the binary age as passed to <tt>libtool</tt>.
--   
--   If <tt>libtool</tt> means nothing to you, don't worry about it.
getBinaryAge :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the GTK debug flags that are currently active.
--   
--   This function is intended for GTK modules that want to adjust their
--   debug output based on GTK debug flags.
getDebugFlags :: (HasCallStack, MonadIO m) => m [DebugFlags]

-- | Returns the <tt>PangoLanguage</tt> for the default language currently
--   in effect.
--   
--   Note that this can change over the life of an application.
--   
--   The default language is derived from the current locale. It
--   determines, for example, whether GTK uses the right-to-left or
--   left-to-right text direction.
--   
--   This function is equivalent to <a>languageGetDefault</a>. See that
--   function for details.
getDefaultLanguage :: (HasCallStack, MonadIO m) => m Language

-- | Returns the interface age as passed to <tt>libtool</tt>.
--   
--   If <tt>libtool</tt> means nothing to you, don't worry about it.
getInterfaceAge :: (HasCallStack, MonadIO m) => m Word32

-- | Gets the direction of the current locale.
--   
--   This is the expected reading direction for text and UI.
--   
--   This function depends on the current locale being set with
--   <tt>setlocale()</tt> and will default to setting the
--   <tt>GTK_TEXT_DIR_LTR</tt> direction otherwise.
--   <tt>GTK_TEXT_DIR_NONE</tt> will never be returned.
--   
--   GTK sets the default text direction according to the locale during
--   <a>init</a>, and you should normally use <a>widgetGetDirection</a> or
--   <a>widgetGetDefaultDirection</a> to obtain the current direction.
--   
--   This function is only needed rare cases when the locale is changed
--   after GTK has already been initialized. In this case, you can use it
--   to update the default text direction as follows:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   #include &lt;locale.h&gt;
--   
--   static void
--   update_locale (const char *new_locale)
--   {
--     setlocale (LC_ALL, new_locale);
--     gtk_widget_set_default_direction (gtk_get_locale_direction ());
--   }
--   </pre>
getLocaleDirection :: (HasCallStack, MonadIO m) => m TextDirection

-- | Returns the major version number of the GTK library.
--   
--   For example, in GTK version 3.1.5 this is 3.
--   
--   This function is in the library, so it represents the GTK library your
--   code is running against. Contrast with the <a>MAJOR_VERSION</a> macro,
--   which represents the major version of the GTK headers you have
--   included when compiling your code.
getMajorVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the micro version number of the GTK library.
--   
--   For example, in GTK version 3.1.5 this is 5.
--   
--   This function is in the library, so it represents the GTK library your
--   code is are running against. Contrast with the <a>MICRO_VERSION</a>
--   macro, which represents the micro version of the GTK headers you have
--   included when compiling your code.
getMicroVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the minor version number of the GTK library.
--   
--   For example, in GTK version 3.1.5 this is 1.
--   
--   This function is in the library, so it represents the GTK library your
--   code is are running against. Contrast with the <a>MINOR_VERSION</a>
--   macro, which represents the minor version of the GTK headers you have
--   included when compiling your code.
getMinorVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Converts a color from HSV space to RGB.
--   
--   Input values must be in the [0.0, 1.0] range; output values will be in
--   the same range.
hsvToRgb :: (HasCallStack, MonadIO m) => Float -> Float -> Float -> m (Float, Float, Float)

-- | Initializes GTK.
--   
--   This function must be called before using any other GTK functions in
--   your GUI applications.
--   
--   It will initialize everything needed to operate the toolkit. In
--   particular, it will open the default display (see
--   <a>displayGetDefault</a>).
--   
--   If you are using <a>Application</a>, you usually don't have to call
--   this function; the <a>Application</a>.<tt><i>startup</i></tt>()
--   handler does it for you. Though, if you are using
--   <tt>GApplication</tt> methods that will be invoked before
--   <tt>startup</tt>, such as <tt>local_command_line</tt>, you may need to
--   initialize GTK explicitly.
--   
--   This function will terminate your program if it was unable to
--   initialize the windowing system for some reason. If you want your
--   program to fall back to a textual interface, call <a>initCheck</a>
--   instead.
--   
--   GTK calls <tt>signal (SIGPIPE, SIG_IGN)</tt> during initialization, to
--   ignore SIGPIPE signals, since these are almost never wanted in
--   graphical applications. If you do need to handle SIGPIPE for some
--   reason, reset the handler after <a>init</a>, but notice that other
--   libraries (e.g. libdbus or gvfs) might do similar things.
init :: (HasCallStack, MonadIO m) => m ()

-- | Initializes GTK.
--   
--   This function does the same work as <a>init</a> with only a single
--   change: It does not terminate the program if the windowing system
--   can’t be initialized. Instead it returns false on failure.
--   
--   This way the application can fall back to some other means of
--   communication with the user - for example a curses or command line
--   interface.
initCheck :: (HasCallStack, MonadIO m) => m Bool

-- | Returns whether GTK has been initialized.
--   
--   See <a>init</a>.
isInitialized :: (HasCallStack, MonadIO m) => m Bool

-- | Creates a new <tt>GParamSpec</tt> instance for a property holding a
--   <tt>GtkExpression</tt>.
--   
--   See <tt>g_param_spec_internal()</tt> for details on the property
--   strings.
paramSpecExpression :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> [ParamFlags] -> m GParamSpec

-- | Runs a page setup dialog, letting the user modify the values from
--   <i><tt>pageSetup</tt></i>.
--   
--   If the user cancels the dialog, the returned <tt>GtkPageSetup</tt> is
--   identical to the passed in <i><tt>pageSetup</tt></i>, otherwise it
--   contains the modifications done in the dialog.
--   
--   Note that this function may use a recursive mainloop to show the page
--   setup dialog. See <a>printRunPageSetupDialogAsync</a> if this is a
--   problem.
printRunPageSetupDialog :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> m PageSetup

-- | Runs a page setup dialog, letting the user modify the values from
--   <i><tt>pageSetup</tt></i>.
--   
--   In contrast to <a>printRunPageSetupDialog</a>, this function returns
--   after showing the page setup dialog on platforms that support this,
--   and calls <i><tt>doneCb</tt></i> from a signal handler for the
--   <a>response</a> signal of the dialog.
printRunPageSetupDialogAsync :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> PageSetupDoneFunc -> m ()

-- | Renders an activity indicator (such as in <tt>GtkSpinner</tt>). The
--   state <a>StateFlagsChecked</a> determines whether there is activity
--   going on.

-- | <i>Deprecated: (Since version 4.10)</i>
renderActivity :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders an arrow pointing to <i><tt>angle</tt></i>.
--   
--   Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderArrow :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders the background of an element.
--   
--   Typical background rendering, showing the effect of
--   <tt>background-image</tt>, <tt>border-width</tt> and
--   <tt>border-radius</tt>:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderBackground :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a checkmark (as in a <tt>GtkCheckButton</tt>).
--   
--   The <a>StateFlagsChecked</a> state determines whether the check is on
--   or off, and <a>StateFlagsInconsistent</a> determines whether it should
--   be marked as undefined.
--   
--   Typical checkmark rendering:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderCheck :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders an expander (as used in <tt>GtkTreeView</tt> and
--   <tt>GtkExpander</tt>) in the area defined by <i><tt>x</tt></i>,
--   <i><tt>y</tt></i>, <i><tt>width</tt></i>, <i><tt>height</tt></i>. The
--   state <a>StateFlagsChecked</a> determines whether the expander is
--   collapsed or expanded.
--   
--   Typical expander rendering:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderExpander :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a focus indicator on the rectangle determined by
--   <i><tt>x</tt></i>, <i><tt>y</tt></i>, <i><tt>width</tt></i>,
--   <i><tt>height</tt></i>.
--   
--   Typical focus rendering:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderFocus :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a frame around the rectangle defined by <i><tt>x</tt></i>,
--   <i><tt>y</tt></i>, <i><tt>width</tt></i>, <i><tt>height</tt></i>.
--   
--   Examples of frame rendering, showing the effect of
--   <tt>border-image</tt>, <tt>border-color</tt>, <tt>border-width</tt>,
--   <tt>border-radius</tt> and junctions:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderFrame :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders a handle (as in <tt>GtkPaned</tt> and <tt>GtkWindow</tt>’s
--   resize grip), in the rectangle determined by <i><tt>x</tt></i>,
--   <i><tt>y</tt></i>, <i><tt>width</tt></i>, <i><tt>height</tt></i>.
--   
--   Handles rendered for the paned and grip classes:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderHandle :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders the icon in <i><tt>texture</tt></i> at the specified
--   <i><tt>x</tt></i> and <i><tt>y</tt></i> coordinates.
--   
--   This function will render the icon in <i><tt>texture</tt></i> at
--   exactly its size, regardless of scaling factors, which may not be
--   appropriate when drawing on displays with high pixel densities.

-- | <i>Deprecated: (Since version 4.10)</i>
renderIcon :: (HasCallStack, MonadIO m, IsStyleContext a, IsTexture b) => a -> Context -> b -> Double -> Double -> m ()

-- | Renders <i><tt>layout</tt></i> on the coordinates <i><tt>x</tt></i>,
--   <i><tt>y</tt></i>

-- | <i>Deprecated: (Since version 4.10)</i>
renderLayout :: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) => a -> Context -> Double -> Double -> b -> m ()

-- | Renders a line from (x0, y0) to (x1, y1).

-- | <i>Deprecated: (Since version 4.10)</i>
renderLine :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Renders an option mark (as in a radio button), the
--   <a>StateFlagsChecked</a> state will determine whether the option is on
--   or off, and <a>StateFlagsInconsistent</a> whether it should be marked
--   as undefined.
--   
--   Typical option mark rendering:
--   

-- | <i>Deprecated: (Since version 4.10)</i>
renderOption :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()

-- | Converts a color from RGB space to HSV.
--   
--   Input values must be in the [0.0, 1.0] range; output values will be in
--   the same range.
rgbToHsv :: (HasCallStack, MonadIO m) => Float -> Float -> Float -> m (Float, Float, Float)

-- | Sets the GTK debug flags.
setDebugFlags :: (HasCallStack, MonadIO m) => [DebugFlags] -> m ()

-- | This function launches the default application for showing a given
--   uri, or shows an error dialog if that fails.

-- | <i>Deprecated: (Since version 4.10)Use <a>fileLauncherLaunch</a>
--   or<a>uriLauncherLaunch</a> instead</i>
showUri :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> Text -> Word32 -> m ()

-- | This function launches the default application for showing a given
--   uri.
--   
--   The <i><tt>callback</tt></i> will be called when the launch is
--   completed.
--   
--   This is the recommended call to be used as it passes information
--   necessary for sandbox helpers to parent their dialogs properly.

-- | <i>Deprecated: (Since version 4.10)Use <a>fileLauncherLaunch</a>
--   or<a>uriLauncherLaunch</a> instead</i>
showUriFull :: (HasCallStack, MonadIO m, IsWindow a, IsCancellable b) => Maybe a -> Text -> Word32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | Finishes the <a>showUri</a> call and returns the result of the
--   operation.

-- | <i>Deprecated: (Since version 4.10)Use <a>fileLauncherLaunch</a>
--   or<a>uriLauncherLaunch</a> instead</i>
showUriFullFinish :: (HasCallStack, MonadIO m, IsWindow a, IsAsyncResult b) => a -> b -> m ()

-- | Prints an assertion message for
--   <tt><i>gtk_test_accessible_assert_role()</i></tt>.
testAccessibleAssertionMessageRole :: (HasCallStack, MonadIO m, IsAccessible a) => Text -> Text -> Int32 -> Text -> Text -> a -> AccessibleRole -> AccessibleRole -> m ()

-- | Checks whether the <tt>GtkAccessible</tt> has <i><tt>property</tt></i>
--   set.
testAccessibleHasProperty :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessibleProperty -> m Bool

-- | Checks whether the <tt>GtkAccessible</tt> has <i><tt>relation</tt></i>
--   set.
testAccessibleHasRelation :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessibleRelation -> m Bool

-- | Checks whether the <tt>GtkAccessible:accessible-role</tt> of the
--   accessible is <i><tt>role</tt></i>.
testAccessibleHasRole :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessibleRole -> m Bool

-- | Checks whether the <tt>GtkAccessible</tt> has <i><tt>state</tt></i>
--   set.
testAccessibleHasState :: (HasCallStack, MonadIO m, IsAccessible a) => a -> AccessibleState -> m Bool

-- | Return the type ids that have been registered after calling
--   <a>testRegisterAllTypes</a>.
testListAllTypes :: (HasCallStack, MonadIO m) => m ([GType], Word32)

-- | Force registration of all core GTK object types.
--   
--   This allows to refer to any of those object types via
--   <a>typeFromName</a> after calling this function.
testRegisterAllTypes :: (HasCallStack, MonadIO m) => m ()

-- | Enters the main loop and waits for <i><tt>widget</tt></i> to be
--   “drawn”.
--   
--   In this context that means it waits for the frame clock of
--   <i><tt>widget</tt></i> to have run a full styling, layout and drawing
--   cycle.
--   
--   This function is intended to be used for syncing with actions that
--   depend on <i><tt>widget</tt></i> relayouting or on interaction with
--   the display server.
testWidgetWaitForDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()

-- | Creates a content provider for dragging <i><tt>path</tt></i> from
--   <i><tt>treeModel</tt></i>.

-- | <i>Deprecated: (Since version 4.10)Use list models instead</i>
treeCreateRowDragContent :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m ContentProvider

-- | Obtains a <i><tt>treeModel</tt></i> and <i><tt>path</tt></i> from
--   value of target type <tt><i>GTK_TYPE_TREE_ROW_DATA</i></tt>.
--   
--   The returned path must be freed with <a>treePathFree</a>.

-- | <i>Deprecated: (Since version 4.10)Use list models instead</i>
treeGetRowDragData :: (HasCallStack, MonadIO m) => GValue -> m (Bool, Maybe TreeModel, Maybe TreePath)

-- | Retrieves the <tt>GtkExpression</tt> stored inside the given
--   <tt>value</tt>, and acquires a reference to it.
valueDupExpression :: (HasCallStack, MonadIO m) => GValue -> m (Maybe Expression)

-- | Retrieves the <tt>GtkExpression</tt> stored inside the given
--   <tt>value</tt>.
valueGetExpression :: (HasCallStack, MonadIO m) => GValue -> m (Maybe Expression)

-- | Stores the given <tt>GtkExpression</tt> inside <tt>value</tt>.
--   
--   The <tt>GValue</tt> will acquire a reference to the
--   <tt>expression</tt>.
valueSetExpression :: (HasCallStack, MonadIO m, IsExpression a) => GValue -> a -> m ()

-- | Stores the given <tt>GtkExpression</tt> inside <tt>value</tt>.
--   
--   This function transfers the ownership of the <tt>expression</tt> to
--   the <tt>GValue</tt>.
valueTakeExpression :: (HasCallStack, MonadIO m, IsExpression a) => GValue -> Maybe a -> m ()


-- | A GtkTreeRowReference tracks model changes so that it always refers to
--   the same row (a <tt>GtkTreePath</tt> refers to a position, not a fixed
--   row). Create a new GtkTreeRowReference with
--   <a>treeRowReferenceNew</a>.
module GI.Gtk.Structs.TreeRowReference

-- | Memory-managed wrapper type.
newtype TreeRowReference
TreeRowReference :: ManagedPtr TreeRowReference -> TreeRowReference

-- | Copies a <tt>GtkTreeRowReference</tt>.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceCopy :: (HasCallStack, MonadIO m) => TreeRowReference -> m TreeRowReference

-- | Lets a set of row reference created by <a>treeRowReferenceNewProxy</a>
--   know that the model emitted the <a>rowDeleted</a> signal.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceDeleted :: (HasCallStack, MonadIO m, IsObject a) => a -> TreePath -> m ()

-- | Free’s <i><tt>reference</tt></i>. <i><tt>reference</tt></i> may be
--   <a>Nothing</a>

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceFree :: (HasCallStack, MonadIO m) => Maybe TreeRowReference -> m ()

-- | Returns the model that the row reference is monitoring.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceGetModel :: (HasCallStack, MonadIO m) => TreeRowReference -> m TreeModel

-- | Returns a path that the row reference currently points to, or
--   <a>Nothing</a> if the path pointed to is no longer valid.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceGetPath :: (HasCallStack, MonadIO m) => TreeRowReference -> m (Maybe TreePath)

-- | Lets a set of row reference created by <a>treeRowReferenceNewProxy</a>
--   know that the model emitted the <a>rowInserted</a> signal.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceInserted :: (HasCallStack, MonadIO m, IsObject a) => a -> TreePath -> m ()

-- | Creates a row reference based on <i><tt>path</tt></i>.
--   
--   This reference will keep pointing to the node pointed to by
--   <i><tt>path</tt></i>, so long as it exists. Any changes that occur on
--   <i><tt>model</tt></i> are propagated, and the path is updated
--   appropriately. If <i><tt>path</tt></i> isn’t a valid path in
--   <i><tt>model</tt></i>, then <a>Nothing</a> is returned.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceNew :: (HasCallStack, MonadIO m, IsTreeModel a) => a -> TreePath -> m (Maybe TreeRowReference)

-- | You do not need to use this function.
--   
--   Creates a row reference based on <i><tt>path</tt></i>.
--   
--   This reference will keep pointing to the node pointed to by
--   <i><tt>path</tt></i>, so long as it exists. If <i><tt>path</tt></i>
--   isn’t a valid path in <i><tt>model</tt></i>, then <a>Nothing</a> is
--   returned. However, unlike references created with
--   <a>treeRowReferenceNew</a>, it does not listen to the model for
--   changes. The creator of the row reference must do this explicitly
--   using <a>treeRowReferenceInserted</a>, <a>treeRowReferenceDeleted</a>,
--   <tt><i>gtk_tree_row_reference_reordered()</i></tt>.
--   
--   These functions must be called exactly once per proxy when the
--   corresponding signal on the model is emitted. This single call updates
--   all row references for that proxy. Since built-in GTK objects like
--   <tt>GtkTreeView</tt> already use this mechanism internally, using them
--   as the proxy object will produce unpredictable results. Further more,
--   passing the same object as <i><tt>model</tt></i> and
--   <i><tt>proxy</tt></i> doesn’t work for reasons of internal
--   implementation.
--   
--   This type of row reference is primarily meant by structures that need
--   to carefully monitor exactly when a row reference updates itself, and
--   is not generally needed by most applications.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceNewProxy :: (HasCallStack, MonadIO m, IsObject a, IsTreeModel b) => a -> b -> TreePath -> m (Maybe TreeRowReference)

-- | Returns <a>True</a> if the <i><tt>reference</tt></i> is
--   non-<a>Nothing</a> and refers to a current valid path.

-- | <i>Deprecated: (Since version 4.10)</i>
treeRowReferenceValid :: (HasCallStack, MonadIO m) => Maybe TreeRowReference -> m Bool
instance GHC.Classes.Eq GI.Gtk.Structs.TreeRowReference.TreeRowReference
instance Data.GI.Base.BasicTypes.GBoxed GI.Gtk.Structs.TreeRowReference.TreeRowReference
instance Data.GI.Base.Overloading.HasParentTypes GI.Gtk.Structs.TreeRowReference.TreeRowReference
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gtk.Structs.TreeRowReference.TreeRowReference)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.TreeRowReference.TreeRowReference
instance Data.GI.Base.BasicTypes.TypedObject GI.Gtk.Structs.TreeRowReference.TreeRowReference


-- | <i>No description available in the introspection data.</i>
module GI.Gtk.Structs.WidgetClass

-- | Memory-managed wrapper type.
newtype WidgetClass
WidgetClass :: ManagedPtr WidgetClass -> WidgetClass

-- | Construct a <a>WidgetClass</a> struct initialized to zero.
newZeroWidgetClass :: MonadIO m => m WidgetClass

-- | Installs a shortcut in <i><tt>widgetClass</tt></i>.
--   
--   Every instance created for <i><tt>widgetClass</tt></i> or its
--   subclasses will inherit this shortcut and trigger it.
--   
--   Shortcuts added this way will be triggered in the
--   <a>PropagationPhaseBubble</a> phase, which means they may also trigger
--   if child widgets have focus.
--   
--   This function must only be used in class initialization functions
--   otherwise it is not guaranteed that the shortcut will be installed.
widgetClassAddShortcut :: (HasCallStack, MonadIO m, IsShortcut a) => WidgetClass -> a -> m ()

-- | Associates a name to be used in GtkBuilder XML with a symbol.
--   
--   This function is not supported after
--   <a>widgetClassSetTemplateScope</a> has been used on
--   <i><tt>widgetClass</tt></i>.
--   
--   See <a>builderCScopeAddCallbackSymbol</a>.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling <a>widgetClassSetTemplate</a>.
widgetClassBindTemplateCallbackFull :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Callback -> m ()

-- | Assigns an object declared in the class template XML to be set to a
--   location on a freshly built instance’s private data, or alternatively
--   accessible via <a>widgetGetTemplateChild</a>.
--   
--   The struct can point either into the public instance, then you should
--   use <tt>G_STRUCT_OFFSET(WidgetType, member)</tt> for
--   <i><tt>structOffset</tt></i>, or in the private struct, then you
--   should use <tt>G_PRIVATE_OFFSET(WidgetType, member)</tt>.
--   
--   An explicit strong reference will be held automatically for the
--   duration of your instance’s life cycle, it will be released
--   automatically when <tt>GObjectClass.dispose()</tt> runs on your
--   instance and if a nonzero <i><tt>structOffset</tt></i> is specified,
--   then the automatic location in your instance public or private data
--   will be set to <tt>NULL</tt>. You can however access an automated
--   child pointer the first time your classes
--   <tt>GObjectClass.dispose()</tt> runs, or alternatively in
--   <a>Widget::destroy</a>.
--   
--   If <i><tt>internalChild</tt></i> is specified,
--   <a>Buildable</a>.<tt><i>get_internal_child</i></tt>() will be
--   automatically implemented by the widget class so there is no need to
--   implement it manually.
--   
--   The wrapper macros
--   <tt><i>Gtk.widget_class_bind_template_child</i></tt>,
--   <tt><i>Gtk.widget_class_bind_template_child_internal</i></tt>,
--   <tt><i>Gtk.widget_class_bind_template_child_private</i></tt> and
--   <tt><i>Gtk.widget_class_bind_template_child_internal_private</i></tt>
--   might be more convenient to use.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling <a>widgetClassSetTemplate</a>.
widgetClassBindTemplateChildFull :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Bool -> Int64 -> m ()

-- | Retrieves the accessible role used by the given widget class.
--   
--   Different accessible roles have different states, and are rendered
--   differently by assistive technologies.
--   
--   See also: <a>accessibleGetAccessibleRole</a>.
widgetClassGetAccessibleRole :: (HasCallStack, MonadIO m) => WidgetClass -> m AccessibleRole

-- | Retrieves the signal id for the activation signal.
--   
--   The activation signal is set using
--   <a>widgetClassSetActivateSignal</a>.
widgetClassGetActivateSignal :: (HasCallStack, MonadIO m) => WidgetClass -> m Word32

-- | Gets the name used by this class for matching in CSS code.
--   
--   See <a>widgetClassSetCssName</a> for details.
widgetClassGetCssName :: (HasCallStack, MonadIO m) => WidgetClass -> m Text

-- | Retrieves the type of the <a>LayoutManager</a> used by widgets of
--   class <i><tt>widgetClass</tt></i>.
--   
--   See also: <a>widgetClassSetLayoutManagerType</a>.
widgetClassGetLayoutManagerType :: (HasCallStack, MonadIO m) => WidgetClass -> m GType

-- | Adds an action for all instances of a widget class.
--   
--   This function should be called at class initialization time.
--   
--   Actions installed by this function are stateless. The only state they
--   have is whether they are enabled or not (which can be changed with
--   <a>widgetActionSetEnabled</a>).
widgetClassInstallAction :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Maybe Text -> WidgetActionActivateFunc -> m ()

-- | Installs an action called <i><tt>actionName</tt></i> on
--   <i><tt>widgetClass</tt></i> and binds its state to the value of the
--   <i><tt>propertyName</tt></i> property.
--   
--   This function will perform a few sanity checks on the property
--   selected via <i><tt>propertyName</tt></i>. Namely, the property must
--   exist, must be readable, writable and must not be construct-only.
--   There are also restrictions on the type of the given property, it must
--   be boolean, int, unsigned int, double or string. If any of these
--   conditions are not met, a critical warning will be printed and no
--   action will be added.
--   
--   The state type of the action matches the property type.
--   
--   If the property is boolean, the action will have no parameter and
--   toggle the property value. Otherwise, the action will have a parameter
--   of the same type as the property.
widgetClassInstallPropertyAction :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> Text -> m ()

-- | Returns details about an action that has been installed for
--   <i><tt>widgetClass</tt></i>.
--   
--   See <a>widgetClassInstallAction</a> for details on how to install
--   actions.
--   
--   Note that this function will also return actions defined by parent
--   classes. You can identify those by looking at <i><tt>owner</tt></i>.
widgetClassQueryAction :: (HasCallStack, MonadIO m) => WidgetClass -> Word32 -> m (Bool, GType, Text, Maybe VariantType, Maybe Text)

-- | Sets the accessible role used by the given widget class.
--   
--   Different accessible roles have different states, and are rendered
--   differently by assistive technologies.
widgetClassSetAccessibleRole :: (HasCallStack, MonadIO m) => WidgetClass -> AccessibleRole -> m ()

-- | Sets the activation signal for a widget class.
--   
--   The signal will be emitted when calling <a>widgetActivate</a>.
--   
--   The <i><tt>signalId</tt></i> must have been registered with
--   [function.GObject.signal_new] or <tt><i>GObject.signal_newv</i></tt>
--   before calling this function.
widgetClassSetActivateSignal :: (HasCallStack, MonadIO m) => WidgetClass -> Word32 -> m ()

-- | Sets the activation signal for a widget class.
--   
--   The signal id will by looked up by <i><tt>signalName</tt></i>.
--   
--   The signal will be emitted when calling <a>widgetActivate</a>.
--   
--   The <i><tt>signalName</tt></i> must have been registered with
--   [function.GObject.signal_new] or <tt><i>GObject.signal_newv</i></tt>
--   before calling this function.
widgetClassSetActivateSignalFromName :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m ()

-- | Sets the name to be used for CSS matching of widgets.
--   
--   If this function is not called for a given class, the name set on the
--   parent class is used. By default, <tt>GtkWidget</tt> uses the name
--   "widget".
widgetClassSetCssName :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m ()

-- | Sets the type to be used for creating layout managers for widgets of
--   <i><tt>widgetClass</tt></i>.
--   
--   The given <i><tt>type</tt></i> must be a subtype of
--   <a>LayoutManager</a>.
--   
--   This function should only be called from class init functions of
--   widgets.
widgetClassSetLayoutManagerType :: (HasCallStack, MonadIO m) => WidgetClass -> GType -> m ()

-- | This should be called at class initialization time to specify the
--   <tt>GtkBuilder</tt> XML to be used to extend a widget.
--   
--   For convenience, <a>widgetClassSetTemplateFromResource</a> is also
--   provided.
--   
--   Note that any class that installs templates must call
--   <a>widgetInitTemplate</a> in the widget’s instance initializer.
widgetClassSetTemplate :: (HasCallStack, MonadIO m) => WidgetClass -> Bytes -> m ()

-- | A convenience function that calls <a>widgetClassSetTemplate</a> with
--   the contents of a resource.
--   
--   Note that any class that installs templates must call
--   <a>widgetInitTemplate</a> in the widget’s instance initializer.
widgetClassSetTemplateFromResource :: (HasCallStack, MonadIO m) => WidgetClass -> Text -> m ()

-- | Overrides the default scope to be used when parsing the class
--   template.
--   
--   This function is intended for language bindings.
--   
--   Note that this must be called from a composite widget classes class
--   initializer after calling <a>widgetClassSetTemplate</a>.
widgetClassSetTemplateScope :: (HasCallStack, MonadIO m, IsBuilderScope a) => WidgetClass -> a -> m ()

-- | Set the value of the “<tt>compute_expand</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #computeExpand
--   </pre>
clearWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>compute_expand</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #computeExpand
--   </pre>
getWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)

-- | Set the value of the “<tt>compute_expand</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #computeExpand <a>:=</a> value ]
--   </pre>
setWidgetClassComputeExpand :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()

-- | Set the value of the “<tt>contains</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #contains
--   </pre>
clearWidgetClassContains :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>contains</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #contains
--   </pre>
getWidgetClassContains :: MonadIO m => WidgetClass -> m (Maybe WidgetClassContainsFieldCallback)

-- | Set the value of the “<tt>contains</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #contains <a>:=</a> value ]
--   </pre>
setWidgetClassContains :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassContainsFieldCallback -> m ()

-- | Set the value of the “<tt>css_changed</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #cssChanged
--   </pre>
clearWidgetClassCssChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>css_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #cssChanged
--   </pre>
getWidgetClassCssChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassCssChangedFieldCallback)

-- | Set the value of the “<tt>css_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #cssChanged <a>:=</a> value ]
--   </pre>
setWidgetClassCssChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassCssChangedFieldCallback -> m ()

-- | Set the value of the “<tt>direction_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #directionChanged
--   </pre>
clearWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>direction_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #directionChanged
--   </pre>
getWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)

-- | Set the value of the “<tt>direction_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #directionChanged <a>:=</a> value ]
--   </pre>
setWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassDirectionChangedFieldCallback -> m ()

-- | Set the value of the “<tt>focus</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #focus
--   </pre>
clearWidgetClassFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>focus</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #focus
--   </pre>
getWidgetClassFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)

-- | Set the value of the “<tt>focus</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #focus <a>:=</a> value ]
--   </pre>
setWidgetClassFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()

-- | Set the value of the “<tt>get_request_mode</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #getRequestMode
--   </pre>
clearWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>get_request_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #getRequestMode
--   </pre>
getWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)

-- | Set the value of the “<tt>get_request_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #getRequestMode <a>:=</a> value ]
--   </pre>
setWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()

-- | Set the value of the “<tt>grab_focus</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #grabFocus
--   </pre>
clearWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>grab_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #grabFocus
--   </pre>
getWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassGrabFocusFieldCallback)

-- | Set the value of the “<tt>grab_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #grabFocus <a>:=</a> value ]
--   </pre>
setWidgetClassGrabFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassGrabFocusFieldCallback -> m ()

-- | Set the value of the “<tt>hide</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #hide
--   </pre>
clearWidgetClassHide :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>hide</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #hide
--   </pre>
getWidgetClassHide :: MonadIO m => WidgetClass -> m (Maybe WidgetClassHideFieldCallback)

-- | Set the value of the “<tt>hide</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #hide <a>:=</a> value ]
--   </pre>
setWidgetClassHide :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassHideFieldCallback -> m ()

-- | Set the value of the “<tt>keynav_failed</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #keynavFailed
--   </pre>
clearWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>keynav_failed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #keynavFailed
--   </pre>
getWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m (Maybe WidgetClassKeynavFailedFieldCallback)

-- | Set the value of the “<tt>keynav_failed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #keynavFailed <a>:=</a> value ]
--   </pre>
setWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassKeynavFailedFieldCallback -> m ()

-- | Set the value of the “<tt>map</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #map
--   </pre>
clearWidgetClassMap :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>map</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #map
--   </pre>
getWidgetClassMap :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMapFieldCallback)

-- | Set the value of the “<tt>map</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #map <a>:=</a> value ]
--   </pre>
setWidgetClassMap :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMapFieldCallback -> m ()

-- | Set the value of the “<tt>measure</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #measure
--   </pre>
clearWidgetClassMeasure :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>measure</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #measure
--   </pre>
getWidgetClassMeasure :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMeasureFieldCallback)

-- | Set the value of the “<tt>measure</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #measure <a>:=</a> value ]
--   </pre>
setWidgetClassMeasure :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMeasureFieldCallback -> m ()

-- | Set the value of the “<tt>mnemonic_activate</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #mnemonicActivate
--   </pre>
clearWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>mnemonic_activate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #mnemonicActivate
--   </pre>
getWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)

-- | Set the value of the “<tt>mnemonic_activate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #mnemonicActivate <a>:=</a> value ]
--   </pre>
setWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()

-- | Set the value of the “<tt>move_focus</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #moveFocus
--   </pre>
clearWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>move_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #moveFocus
--   </pre>
getWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)

-- | Set the value of the “<tt>move_focus</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #moveFocus <a>:=</a> value ]
--   </pre>
setWidgetClassMoveFocus :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassMoveFocusFieldCallback -> m ()

-- | Get the value of the “<tt>parent_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #parentClass
--   </pre>
getWidgetClassParentClass :: MonadIO m => WidgetClass -> m InitiallyUnownedClass

-- | Set the value of the “<tt>query_tooltip</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #queryTooltip
--   </pre>
clearWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>query_tooltip</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #queryTooltip
--   </pre>
getWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)

-- | Set the value of the “<tt>query_tooltip</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #queryTooltip <a>:=</a> value ]
--   </pre>
setWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()

-- | Set the value of the “<tt>realize</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #realize
--   </pre>
clearWidgetClassRealize :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>realize</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #realize
--   </pre>
getWidgetClassRealize :: MonadIO m => WidgetClass -> m (Maybe WidgetClassRealizeFieldCallback)

-- | Set the value of the “<tt>realize</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #realize <a>:=</a> value ]
--   </pre>
setWidgetClassRealize :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassRealizeFieldCallback -> m ()

-- | Set the value of the “<tt>root</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #root
--   </pre>
clearWidgetClassRoot :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>root</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #root
--   </pre>
getWidgetClassRoot :: MonadIO m => WidgetClass -> m (Maybe WidgetClassRootFieldCallback)

-- | Set the value of the “<tt>root</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #root <a>:=</a> value ]
--   </pre>
setWidgetClassRoot :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassRootFieldCallback -> m ()

-- | Set the value of the “<tt>set_focus_child</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #setFocusChild
--   </pre>
clearWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>set_focus_child</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #setFocusChild
--   </pre>
getWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSetFocusChildFieldCallback)

-- | Set the value of the “<tt>set_focus_child</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #setFocusChild <a>:=</a> value ]
--   </pre>
setWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSetFocusChildFieldCallback -> m ()

-- | Set the value of the “<tt>show</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #show
--   </pre>
clearWidgetClassShow :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>show</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #show
--   </pre>
getWidgetClassShow :: MonadIO m => WidgetClass -> m (Maybe WidgetClassShowFieldCallback)

-- | Set the value of the “<tt>show</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #show <a>:=</a> value ]
--   </pre>
setWidgetClassShow :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()

-- | Set the value of the “<tt>size_allocate</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #sizeAllocate
--   </pre>
clearWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>size_allocate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #sizeAllocate
--   </pre>
getWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)

-- | Set the value of the “<tt>size_allocate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #sizeAllocate <a>:=</a> value ]
--   </pre>
setWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()

-- | Set the value of the “<tt>snapshot</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #snapshot
--   </pre>
clearWidgetClassSnapshot :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>snapshot</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #snapshot
--   </pre>
getWidgetClassSnapshot :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSnapshotFieldCallback)

-- | Set the value of the “<tt>snapshot</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #snapshot <a>:=</a> value ]
--   </pre>
setWidgetClassSnapshot :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSnapshotFieldCallback -> m ()

-- | Set the value of the “<tt>state_flags_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #stateFlagsChanged
--   </pre>
clearWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>state_flags_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #stateFlagsChanged
--   </pre>
getWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)

-- | Set the value of the “<tt>state_flags_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #stateFlagsChanged <a>:=</a> value ]
--   </pre>
setWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()

-- | Set the value of the “<tt>system_setting_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #systemSettingChanged
--   </pre>
clearWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>system_setting_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #systemSettingChanged
--   </pre>
getWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m (Maybe WidgetClassSystemSettingChangedFieldCallback)

-- | Set the value of the “<tt>system_setting_changed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #systemSettingChanged <a>:=</a> value ]
--   </pre>
setWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassSystemSettingChangedFieldCallback -> m ()

-- | Set the value of the “<tt>unmap</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #unmap
--   </pre>
clearWidgetClassUnmap :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>unmap</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #unmap
--   </pre>
getWidgetClassUnmap :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnmapFieldCallback)

-- | Set the value of the “<tt>unmap</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #unmap <a>:=</a> value ]
--   </pre>
setWidgetClassUnmap :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnmapFieldCallback -> m ()

-- | Set the value of the “<tt>unrealize</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #unrealize
--   </pre>
clearWidgetClassUnrealize :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>unrealize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #unrealize
--   </pre>
getWidgetClassUnrealize :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnrealizeFieldCallback)

-- | Set the value of the “<tt>unrealize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #unrealize <a>:=</a> value ]
--   </pre>
setWidgetClassUnrealize :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnrealizeFieldCallback -> m ()

-- | Set the value of the “<tt>unroot</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #unroot
--   </pre>
clearWidgetClassUnroot :: MonadIO m => WidgetClass -> m ()

-- | Get the value of the “<tt>unroot</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> widgetClass #unroot
--   </pre>
getWidgetClassUnroot :: MonadIO m => WidgetClass -> m (Maybe WidgetClassUnrootFieldCallback)

-- | Set the value of the “<tt>unroot</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> widgetClass [ #unroot <a>:=</a> value ]
--   </pre>
setWidgetClassUnroot :: MonadIO m => WidgetClass -> FunPtr C_WidgetClassUnrootFieldCallback -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gtk.Structs.WidgetClass.WidgetClass
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gtk.Structs.WidgetClass.WidgetClass
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gtk.Structs.WidgetClass.WidgetClass tag
instance GHC.Classes.Eq GI.Gtk.Structs.WidgetClass.WidgetClass
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gtk.Structs.WidgetClass.WidgetClass


module GI.Gtk.Structs


module GI.Gtk
