{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) The 'GI.Gtk.Objects.CellRenderer.CellRenderer' is a base class of a set of objects used for rendering a cell to a 'GI.Cairo.Structs.Context.Context'. These objects are used primarily by the 'GI.Gtk.Objects.TreeView.TreeView' widget, though they aren’t tied to them in any specific way. It is worth noting that 'GI.Gtk.Objects.CellRenderer.CellRenderer' is not a 'GI.Gtk.Objects.Widget.Widget' and cannot be treated as such. The primary use of a 'GI.Gtk.Objects.CellRenderer.CellRenderer' is for drawing a certain graphical elements on a 'GI.Cairo.Structs.Context.Context'. 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 @/GObjects/@ property system. Then, the cell is measured using 'GI.Gtk.Objects.CellRenderer.cellRendererGetSize'. Finally, the cell is rendered in the correct location using 'GI.Gtk.Objects.CellRenderer.cellRendererRender'. There are a number of rules that must be followed when writing a new 'GI.Gtk.Objects.CellRenderer.CellRenderer'. First and foremost, it’s important that a certain set of properties will always yield a cell renderer of the same size, barring a 'GI.Gtk.Objects.Style.Style' change. The 'GI.Gtk.Objects.CellRenderer.CellRenderer' 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 'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle', which toggles when it gets activated by a mouse click, or it can be “editable” like 'GI.Gtk.Objects.CellRendererText.CellRendererText', which allows the user to edit the text using a widget implementing the 'GI.Gtk.Interfaces.CellEditable.CellEditable' interface, e.g. 'GI.Gtk.Objects.Entry.Entry'. To make a cell renderer activatable or editable, you have to implement the 'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/activate/@ or 'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/start_editing/@ virtual functions, respectively. Many properties of 'GI.Gtk.Objects.CellRenderer.CellRenderer' 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. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Objects.CellRenderer ( -- * Exported types CellRenderer(..) , IsCellRenderer , toCellRenderer , noCellRenderer , -- * Methods -- ** activate #method:activate# #if ENABLE_OVERLOADING CellRendererActivateMethodInfo , #endif cellRendererActivate , -- ** getAlignedArea #method:getAlignedArea# #if ENABLE_OVERLOADING CellRendererGetAlignedAreaMethodInfo , #endif cellRendererGetAlignedArea , -- ** getAlignment #method:getAlignment# #if ENABLE_OVERLOADING CellRendererGetAlignmentMethodInfo , #endif cellRendererGetAlignment , -- ** getFixedSize #method:getFixedSize# #if ENABLE_OVERLOADING CellRendererGetFixedSizeMethodInfo , #endif cellRendererGetFixedSize , -- ** getPadding #method:getPadding# #if ENABLE_OVERLOADING CellRendererGetPaddingMethodInfo , #endif cellRendererGetPadding , -- ** getPreferredHeight #method:getPreferredHeight# #if ENABLE_OVERLOADING CellRendererGetPreferredHeightMethodInfo, #endif cellRendererGetPreferredHeight , -- ** getPreferredHeightForWidth #method:getPreferredHeightForWidth# #if ENABLE_OVERLOADING CellRendererGetPreferredHeightForWidthMethodInfo, #endif cellRendererGetPreferredHeightForWidth , -- ** getPreferredSize #method:getPreferredSize# #if ENABLE_OVERLOADING CellRendererGetPreferredSizeMethodInfo , #endif cellRendererGetPreferredSize , -- ** getPreferredWidth #method:getPreferredWidth# #if ENABLE_OVERLOADING CellRendererGetPreferredWidthMethodInfo , #endif cellRendererGetPreferredWidth , -- ** getPreferredWidthForHeight #method:getPreferredWidthForHeight# #if ENABLE_OVERLOADING CellRendererGetPreferredWidthForHeightMethodInfo, #endif cellRendererGetPreferredWidthForHeight , -- ** getRequestMode #method:getRequestMode# #if ENABLE_OVERLOADING CellRendererGetRequestModeMethodInfo , #endif cellRendererGetRequestMode , -- ** getSensitive #method:getSensitive# #if ENABLE_OVERLOADING CellRendererGetSensitiveMethodInfo , #endif cellRendererGetSensitive , -- ** getSize #method:getSize# #if ENABLE_OVERLOADING CellRendererGetSizeMethodInfo , #endif cellRendererGetSize , -- ** getState #method:getState# #if ENABLE_OVERLOADING CellRendererGetStateMethodInfo , #endif cellRendererGetState , -- ** getVisible #method:getVisible# #if ENABLE_OVERLOADING CellRendererGetVisibleMethodInfo , #endif cellRendererGetVisible , -- ** isActivatable #method:isActivatable# #if ENABLE_OVERLOADING CellRendererIsActivatableMethodInfo , #endif cellRendererIsActivatable , -- ** render #method:render# #if ENABLE_OVERLOADING CellRendererRenderMethodInfo , #endif cellRendererRender , -- ** setAlignment #method:setAlignment# #if ENABLE_OVERLOADING CellRendererSetAlignmentMethodInfo , #endif cellRendererSetAlignment , -- ** setFixedSize #method:setFixedSize# #if ENABLE_OVERLOADING CellRendererSetFixedSizeMethodInfo , #endif cellRendererSetFixedSize , -- ** setPadding #method:setPadding# #if ENABLE_OVERLOADING CellRendererSetPaddingMethodInfo , #endif cellRendererSetPadding , -- ** setSensitive #method:setSensitive# #if ENABLE_OVERLOADING CellRendererSetSensitiveMethodInfo , #endif cellRendererSetSensitive , -- ** setVisible #method:setVisible# #if ENABLE_OVERLOADING CellRendererSetVisibleMethodInfo , #endif cellRendererSetVisible , -- ** startEditing #method:startEditing# #if ENABLE_OVERLOADING CellRendererStartEditingMethodInfo , #endif cellRendererStartEditing , -- ** stopEditing #method:stopEditing# #if ENABLE_OVERLOADING CellRendererStopEditingMethodInfo , #endif cellRendererStopEditing , -- * Properties -- ** cellBackground #attr:cellBackground# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererCellBackgroundPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererCellBackground , #endif clearCellRendererCellBackground , constructCellRendererCellBackground , setCellRendererCellBackground , -- ** cellBackgroundGdk #attr:cellBackgroundGdk# {- | Cell background as a 'GI.Gdk.Structs.Color.Color' -} #if ENABLE_OVERLOADING CellRendererCellBackgroundGdkPropertyInfo, #endif #if ENABLE_OVERLOADING cellRendererCellBackgroundGdk , #endif clearCellRendererCellBackgroundGdk , constructCellRendererCellBackgroundGdk , getCellRendererCellBackgroundGdk , setCellRendererCellBackgroundGdk , -- ** cellBackgroundRgba #attr:cellBackgroundRgba# {- | Cell background as a 'GI.Gdk.Structs.RGBA.RGBA' /Since: 3.0/ -} #if ENABLE_OVERLOADING CellRendererCellBackgroundRgbaPropertyInfo, #endif #if ENABLE_OVERLOADING cellRendererCellBackgroundRgba , #endif clearCellRendererCellBackgroundRgba , constructCellRendererCellBackgroundRgba , getCellRendererCellBackgroundRgba , setCellRendererCellBackgroundRgba , -- ** cellBackgroundSet #attr:cellBackgroundSet# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererCellBackgroundSetPropertyInfo, #endif #if ENABLE_OVERLOADING cellRendererCellBackgroundSet , #endif constructCellRendererCellBackgroundSet , getCellRendererCellBackgroundSet , setCellRendererCellBackgroundSet , -- ** editing #attr:editing# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererEditingPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererEditing , #endif getCellRendererEditing , -- ** height #attr:height# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererHeightPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererHeight , #endif constructCellRendererHeight , getCellRendererHeight , setCellRendererHeight , -- ** isExpanded #attr:isExpanded# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererIsExpandedPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererIsExpanded , #endif constructCellRendererIsExpanded , getCellRendererIsExpanded , setCellRendererIsExpanded , -- ** isExpander #attr:isExpander# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererIsExpanderPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererIsExpander , #endif constructCellRendererIsExpander , getCellRendererIsExpander , setCellRendererIsExpander , -- ** mode #attr:mode# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererModePropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererMode , #endif constructCellRendererMode , getCellRendererMode , setCellRendererMode , -- ** sensitive #attr:sensitive# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererSensitivePropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererSensitive , #endif constructCellRendererSensitive , getCellRendererSensitive , setCellRendererSensitive , -- ** visible #attr:visible# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererVisiblePropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererVisible , #endif constructCellRendererVisible , getCellRendererVisible , setCellRendererVisible , -- ** width #attr:width# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererWidthPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererWidth , #endif constructCellRendererWidth , getCellRendererWidth , setCellRendererWidth , -- ** xalign #attr:xalign# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererXalignPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererXalign , #endif constructCellRendererXalign , getCellRendererXalign , setCellRendererXalign , -- ** xpad #attr:xpad# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererXpadPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererXpad , #endif constructCellRendererXpad , getCellRendererXpad , setCellRendererXpad , -- ** yalign #attr:yalign# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererYalignPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererYalign , #endif constructCellRendererYalign , getCellRendererYalign , setCellRendererYalign , -- ** ypad #attr:ypad# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING CellRendererYpadPropertyInfo , #endif #if ENABLE_OVERLOADING cellRendererYpad , #endif constructCellRendererYpad , getCellRendererYpad , setCellRendererYpad , -- * Signals -- ** editingCanceled #signal:editingCanceled# C_CellRendererEditingCanceledCallback , CellRendererEditingCanceledCallback , #if ENABLE_OVERLOADING CellRendererEditingCanceledSignalInfo , #endif afterCellRendererEditingCanceled , genClosure_CellRendererEditingCanceled , mk_CellRendererEditingCanceledCallback , noCellRendererEditingCanceledCallback , onCellRendererEditingCanceled , wrap_CellRendererEditingCanceledCallback, -- ** editingStarted #signal:editingStarted# C_CellRendererEditingStartedCallback , CellRendererEditingStartedCallback , #if ENABLE_OVERLOADING CellRendererEditingStartedSignalInfo , #endif afterCellRendererEditingStarted , genClosure_CellRendererEditingStarted , mk_CellRendererEditingStartedCallback , noCellRendererEditingStartedCallback , onCellRendererEditingStarted , wrap_CellRendererEditingStartedCallback , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.Cairo.Structs.Context as Cairo.Context import qualified GI.GObject.Objects.Object as GObject.Object import qualified GI.Gdk.Structs.Color as Gdk.Color import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle import qualified GI.Gdk.Unions.Event as Gdk.Event import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags import {-# SOURCE #-} qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition -- | Memory-managed wrapper type. newtype CellRenderer = CellRenderer (ManagedPtr CellRenderer) foreign import ccall "gtk_cell_renderer_get_type" c_gtk_cell_renderer_get_type :: IO GType instance GObject CellRenderer where gobjectType = c_gtk_cell_renderer_get_type -- | Type class for types which can be safely cast to `CellRenderer`, for instance with `toCellRenderer`. class (GObject o, O.IsDescendantOf CellRenderer o) => IsCellRenderer o instance (GObject o, O.IsDescendantOf CellRenderer o) => IsCellRenderer o instance O.HasParentTypes CellRenderer type instance O.ParentTypes CellRenderer = '[GObject.Object.Object] -- | Cast to `CellRenderer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toCellRenderer :: (MonadIO m, IsCellRenderer o) => o -> m CellRenderer toCellRenderer = liftIO . unsafeCastTo CellRenderer -- | A convenience alias for `Nothing` :: `Maybe` `CellRenderer`. noCellRenderer :: Maybe CellRenderer noCellRenderer = Nothing #if ENABLE_OVERLOADING type family ResolveCellRendererMethod (t :: Symbol) (o :: *) :: * where ResolveCellRendererMethod "activate" o = CellRendererActivateMethodInfo ResolveCellRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveCellRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveCellRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveCellRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveCellRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveCellRendererMethod "isActivatable" o = CellRendererIsActivatableMethodInfo ResolveCellRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveCellRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveCellRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveCellRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveCellRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveCellRendererMethod "render" o = CellRendererRenderMethodInfo ResolveCellRendererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveCellRendererMethod "startEditing" o = CellRendererStartEditingMethodInfo ResolveCellRendererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveCellRendererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveCellRendererMethod "stopEditing" o = CellRendererStopEditingMethodInfo ResolveCellRendererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveCellRendererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveCellRendererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveCellRendererMethod "getAlignedArea" o = CellRendererGetAlignedAreaMethodInfo ResolveCellRendererMethod "getAlignment" o = CellRendererGetAlignmentMethodInfo ResolveCellRendererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveCellRendererMethod "getFixedSize" o = CellRendererGetFixedSizeMethodInfo ResolveCellRendererMethod "getPadding" o = CellRendererGetPaddingMethodInfo ResolveCellRendererMethod "getPreferredHeight" o = CellRendererGetPreferredHeightMethodInfo ResolveCellRendererMethod "getPreferredHeightForWidth" o = CellRendererGetPreferredHeightForWidthMethodInfo ResolveCellRendererMethod "getPreferredSize" o = CellRendererGetPreferredSizeMethodInfo ResolveCellRendererMethod "getPreferredWidth" o = CellRendererGetPreferredWidthMethodInfo ResolveCellRendererMethod "getPreferredWidthForHeight" o = CellRendererGetPreferredWidthForHeightMethodInfo ResolveCellRendererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveCellRendererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveCellRendererMethod "getRequestMode" o = CellRendererGetRequestModeMethodInfo ResolveCellRendererMethod "getSensitive" o = CellRendererGetSensitiveMethodInfo ResolveCellRendererMethod "getSize" o = CellRendererGetSizeMethodInfo ResolveCellRendererMethod "getState" o = CellRendererGetStateMethodInfo ResolveCellRendererMethod "getVisible" o = CellRendererGetVisibleMethodInfo ResolveCellRendererMethod "setAlignment" o = CellRendererSetAlignmentMethodInfo ResolveCellRendererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveCellRendererMethod "setFixedSize" o = CellRendererSetFixedSizeMethodInfo ResolveCellRendererMethod "setPadding" o = CellRendererSetPaddingMethodInfo ResolveCellRendererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveCellRendererMethod "setSensitive" o = CellRendererSetSensitiveMethodInfo ResolveCellRendererMethod "setVisible" o = CellRendererSetVisibleMethodInfo ResolveCellRendererMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveCellRendererMethod t CellRenderer, O.MethodInfo info CellRenderer p) => OL.IsLabel t (CellRenderer -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal CellRenderer::editing-canceled {- | 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: 'GI.Gtk.Objects.CellRenderer.cellRendererStopEditing'. /Since: 2.4/ -} type CellRendererEditingCanceledCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `CellRendererEditingCanceledCallback`@. noCellRendererEditingCanceledCallback :: Maybe CellRendererEditingCanceledCallback noCellRendererEditingCanceledCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_CellRendererEditingCanceledCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_CellRendererEditingCanceledCallback`. foreign import ccall "wrapper" mk_CellRendererEditingCanceledCallback :: C_CellRendererEditingCanceledCallback -> IO (FunPtr C_CellRendererEditingCanceledCallback) -- | Wrap the callback into a `GClosure`. genClosure_CellRendererEditingCanceled :: MonadIO m => CellRendererEditingCanceledCallback -> m (GClosure C_CellRendererEditingCanceledCallback) genClosure_CellRendererEditingCanceled cb = liftIO $ do let cb' = wrap_CellRendererEditingCanceledCallback cb mk_CellRendererEditingCanceledCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `CellRendererEditingCanceledCallback` into a `C_CellRendererEditingCanceledCallback`. wrap_CellRendererEditingCanceledCallback :: CellRendererEditingCanceledCallback -> C_CellRendererEditingCanceledCallback wrap_CellRendererEditingCanceledCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@editing-canceled@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' cellRenderer #editingCanceled callback @ -} onCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId onCellRendererEditingCanceled obj cb = liftIO $ do let cb' = wrap_CellRendererEditingCanceledCallback cb cb'' <- mk_CellRendererEditingCanceledCallback cb' connectSignalFunPtr obj "editing-canceled" cb'' SignalConnectBefore {- | Connect a signal handler for the “@editing-canceled@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' cellRenderer #editingCanceled callback @ -} afterCellRendererEditingCanceled :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId afterCellRendererEditingCanceled obj cb = liftIO $ do let cb' = wrap_CellRendererEditingCanceledCallback cb cb'' <- mk_CellRendererEditingCanceledCallback cb' connectSignalFunPtr obj "editing-canceled" cb'' SignalConnectAfter -- signal CellRenderer::editing-started {- | This signal gets emitted when a cell starts to be edited. The intended use of this signal is to do special setup on /@editable@/, e.g. adding a 'GI.Gtk.Objects.EntryCompletion.EntryCompletion' or setting up additional columns in a 'GI.Gtk.Objects.ComboBox.ComboBox'. See 'GI.Gtk.Interfaces.CellEditable.cellEditableStartEditing' for information on the lifecycle of the /@editable@/ and a way to do setup that doesn’t depend on the /@renderer@/. 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 /@editable@/ before doing any specific setup, as in the following example: === /C code/ > >static void >text_editing_started (GtkCellRenderer *cell, > GtkCellEditable *editable, > const gchar *path, > gpointer data) >{ > if (GTK_IS_ENTRY (editable)) > { > GtkEntry *entry = GTK_ENTRY (editable); > > // ... create a GtkEntryCompletion > > gtk_entry_set_completion (entry, completion); > } >} /Since: 2.6/ -} type CellRendererEditingStartedCallback = Gtk.CellEditable.CellEditable {- ^ /@editable@/: the 'GI.Gtk.Interfaces.CellEditable.CellEditable' -} -> T.Text {- ^ /@path@/: the path identifying the edited cell -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `CellRendererEditingStartedCallback`@. noCellRendererEditingStartedCallback :: Maybe CellRendererEditingStartedCallback noCellRendererEditingStartedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_CellRendererEditingStartedCallback = Ptr () -> -- object Ptr Gtk.CellEditable.CellEditable -> CString -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_CellRendererEditingStartedCallback`. foreign import ccall "wrapper" mk_CellRendererEditingStartedCallback :: C_CellRendererEditingStartedCallback -> IO (FunPtr C_CellRendererEditingStartedCallback) -- | Wrap the callback into a `GClosure`. genClosure_CellRendererEditingStarted :: MonadIO m => CellRendererEditingStartedCallback -> m (GClosure C_CellRendererEditingStartedCallback) genClosure_CellRendererEditingStarted cb = liftIO $ do let cb' = wrap_CellRendererEditingStartedCallback cb mk_CellRendererEditingStartedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `CellRendererEditingStartedCallback` into a `C_CellRendererEditingStartedCallback`. wrap_CellRendererEditingStartedCallback :: CellRendererEditingStartedCallback -> C_CellRendererEditingStartedCallback wrap_CellRendererEditingStartedCallback _cb _ editable path _ = do editable' <- (newObject Gtk.CellEditable.CellEditable) editable path' <- cstringToText path _cb editable' path' {- | Connect a signal handler for the “@editing-started@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' cellRenderer #editingStarted callback @ -} onCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId onCellRendererEditingStarted obj cb = liftIO $ do let cb' = wrap_CellRendererEditingStartedCallback cb cb'' <- mk_CellRendererEditingStartedCallback cb' connectSignalFunPtr obj "editing-started" cb'' SignalConnectBefore {- | Connect a signal handler for the “@editing-started@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' cellRenderer #editingStarted callback @ -} afterCellRendererEditingStarted :: (IsCellRenderer a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId afterCellRendererEditingStarted obj cb = liftIO $ do let cb' = wrap_CellRendererEditingStartedCallback cb cb'' <- mk_CellRendererEditingStartedCallback cb' connectSignalFunPtr obj "editing-started" cb'' SignalConnectAfter -- VVV Prop "cell-background" -- Type: TBasicType TUTF8 -- Flags: [PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Set the value of the “@cell-background@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #cellBackground 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> T.Text -> m () setCellRendererCellBackground obj val = liftIO $ B.Properties.setObjectPropertyString obj "cell-background" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@cell-background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererCellBackground :: (IsCellRenderer o) => T.Text -> IO (GValueConstruct o) constructCellRendererCellBackground val = B.Properties.constructObjectPropertyString "cell-background" (Just val) {- | Set the value of the “@cell-background@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #cellBackground @ -} clearCellRendererCellBackground :: (MonadIO m, IsCellRenderer o) => o -> m () clearCellRendererCellBackground obj = liftIO $ B.Properties.setObjectPropertyString obj "cell-background" (Nothing :: Maybe T.Text) #if ENABLE_OVERLOADING data CellRendererCellBackgroundPropertyInfo instance AttrInfo CellRendererCellBackgroundPropertyInfo where type AttrAllowedOps CellRendererCellBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear] type AttrSetTypeConstraint CellRendererCellBackgroundPropertyInfo = (~) T.Text type AttrBaseTypeConstraint CellRendererCellBackgroundPropertyInfo = IsCellRenderer type AttrGetType CellRendererCellBackgroundPropertyInfo = () type AttrLabel CellRendererCellBackgroundPropertyInfo = "cell-background" type AttrOrigin CellRendererCellBackgroundPropertyInfo = CellRenderer attrGet _ = undefined attrSet _ = setCellRendererCellBackground attrConstruct _ = constructCellRendererCellBackground attrClear _ = clearCellRendererCellBackground #endif -- VVV Prop "cell-background-gdk" -- Type: TInterface (Name {namespace = "Gdk", name = "Color"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@cell-background-gdk@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #cellBackgroundGdk @ -} getCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe Gdk.Color.Color) getCellRendererCellBackgroundGdk obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "cell-background-gdk" Gdk.Color.Color {- | Set the value of the “@cell-background-gdk@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #cellBackgroundGdk 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> Gdk.Color.Color -> m () setCellRendererCellBackgroundGdk obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-gdk" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@cell-background-gdk@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererCellBackgroundGdk :: (IsCellRenderer o) => Gdk.Color.Color -> IO (GValueConstruct o) constructCellRendererCellBackgroundGdk val = B.Properties.constructObjectPropertyBoxed "cell-background-gdk" (Just val) {- | Set the value of the “@cell-background-gdk@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #cellBackgroundGdk @ -} clearCellRendererCellBackgroundGdk :: (MonadIO m, IsCellRenderer o) => o -> m () clearCellRendererCellBackgroundGdk obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-gdk" (Nothing :: Maybe Gdk.Color.Color) #if ENABLE_OVERLOADING data CellRendererCellBackgroundGdkPropertyInfo instance AttrInfo CellRendererCellBackgroundGdkPropertyInfo where type AttrAllowedOps CellRendererCellBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color.Color type AttrBaseTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = IsCellRenderer type AttrGetType CellRendererCellBackgroundGdkPropertyInfo = (Maybe Gdk.Color.Color) type AttrLabel CellRendererCellBackgroundGdkPropertyInfo = "cell-background-gdk" type AttrOrigin CellRendererCellBackgroundGdkPropertyInfo = CellRenderer attrGet _ = getCellRendererCellBackgroundGdk attrSet _ = setCellRendererCellBackgroundGdk attrConstruct _ = constructCellRendererCellBackgroundGdk attrClear _ = clearCellRendererCellBackgroundGdk #endif -- VVV Prop "cell-background-rgba" -- Type: TInterface (Name {namespace = "Gdk", name = "RGBA"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@cell-background-rgba@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #cellBackgroundRgba @ -} getCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m (Maybe Gdk.RGBA.RGBA) getCellRendererCellBackgroundRgba obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "cell-background-rgba" Gdk.RGBA.RGBA {- | Set the value of the “@cell-background-rgba@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #cellBackgroundRgba 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> Gdk.RGBA.RGBA -> m () setCellRendererCellBackgroundRgba obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-rgba" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@cell-background-rgba@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererCellBackgroundRgba :: (IsCellRenderer o) => Gdk.RGBA.RGBA -> IO (GValueConstruct o) constructCellRendererCellBackgroundRgba val = B.Properties.constructObjectPropertyBoxed "cell-background-rgba" (Just val) {- | Set the value of the “@cell-background-rgba@” property to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #cellBackgroundRgba @ -} clearCellRendererCellBackgroundRgba :: (MonadIO m, IsCellRenderer o) => o -> m () clearCellRendererCellBackgroundRgba obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "cell-background-rgba" (Nothing :: Maybe Gdk.RGBA.RGBA) #if ENABLE_OVERLOADING data CellRendererCellBackgroundRgbaPropertyInfo instance AttrInfo CellRendererCellBackgroundRgbaPropertyInfo where type AttrAllowedOps CellRendererCellBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = (~) Gdk.RGBA.RGBA type AttrBaseTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = IsCellRenderer type AttrGetType CellRendererCellBackgroundRgbaPropertyInfo = (Maybe Gdk.RGBA.RGBA) type AttrLabel CellRendererCellBackgroundRgbaPropertyInfo = "cell-background-rgba" type AttrOrigin CellRendererCellBackgroundRgbaPropertyInfo = CellRenderer attrGet _ = getCellRendererCellBackgroundRgba attrSet _ = setCellRendererCellBackgroundRgba attrConstruct _ = constructCellRendererCellBackgroundRgba attrClear _ = clearCellRendererCellBackgroundRgba #endif -- VVV Prop "cell-background-set" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@cell-background-set@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #cellBackgroundSet @ -} getCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> m Bool getCellRendererCellBackgroundSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "cell-background-set" {- | Set the value of the “@cell-background-set@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #cellBackgroundSet 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererCellBackgroundSet :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m () setCellRendererCellBackgroundSet obj val = liftIO $ B.Properties.setObjectPropertyBool obj "cell-background-set" val {- | Construct a `GValueConstruct` with valid value for the “@cell-background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererCellBackgroundSet :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o) constructCellRendererCellBackgroundSet val = B.Properties.constructObjectPropertyBool "cell-background-set" val #if ENABLE_OVERLOADING data CellRendererCellBackgroundSetPropertyInfo instance AttrInfo CellRendererCellBackgroundSetPropertyInfo where type AttrAllowedOps CellRendererCellBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererCellBackgroundSetPropertyInfo = (~) Bool type AttrBaseTypeConstraint CellRendererCellBackgroundSetPropertyInfo = IsCellRenderer type AttrGetType CellRendererCellBackgroundSetPropertyInfo = Bool type AttrLabel CellRendererCellBackgroundSetPropertyInfo = "cell-background-set" type AttrOrigin CellRendererCellBackgroundSetPropertyInfo = CellRenderer attrGet _ = getCellRendererCellBackgroundSet attrSet _ = setCellRendererCellBackgroundSet attrConstruct _ = constructCellRendererCellBackgroundSet attrClear _ = undefined #endif -- VVV Prop "editing" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@editing@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #editing @ -} getCellRendererEditing :: (MonadIO m, IsCellRenderer o) => o -> m Bool getCellRendererEditing obj = liftIO $ B.Properties.getObjectPropertyBool obj "editing" #if ENABLE_OVERLOADING data CellRendererEditingPropertyInfo instance AttrInfo CellRendererEditingPropertyInfo where type AttrAllowedOps CellRendererEditingPropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint CellRendererEditingPropertyInfo = (~) () type AttrBaseTypeConstraint CellRendererEditingPropertyInfo = IsCellRenderer type AttrGetType CellRendererEditingPropertyInfo = Bool type AttrLabel CellRendererEditingPropertyInfo = "editing" type AttrOrigin CellRendererEditingPropertyInfo = CellRenderer attrGet _ = getCellRendererEditing attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "height" -- Type: TBasicType TInt -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@height@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #height @ -} getCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> m Int32 getCellRendererHeight obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "height" {- | Set the value of the “@height@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #height 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererHeight :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m () setCellRendererHeight obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "height" val {- | Construct a `GValueConstruct` with valid value for the “@height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererHeight :: (IsCellRenderer o) => Int32 -> IO (GValueConstruct o) constructCellRendererHeight val = B.Properties.constructObjectPropertyInt32 "height" val #if ENABLE_OVERLOADING data CellRendererHeightPropertyInfo instance AttrInfo CellRendererHeightPropertyInfo where type AttrAllowedOps CellRendererHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererHeightPropertyInfo = (~) Int32 type AttrBaseTypeConstraint CellRendererHeightPropertyInfo = IsCellRenderer type AttrGetType CellRendererHeightPropertyInfo = Int32 type AttrLabel CellRendererHeightPropertyInfo = "height" type AttrOrigin CellRendererHeightPropertyInfo = CellRenderer attrGet _ = getCellRendererHeight attrSet _ = setCellRendererHeight attrConstruct _ = constructCellRendererHeight attrClear _ = undefined #endif -- VVV Prop "is-expanded" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@is-expanded@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #isExpanded @ -} getCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> m Bool getCellRendererIsExpanded obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-expanded" {- | Set the value of the “@is-expanded@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #isExpanded 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererIsExpanded :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m () setCellRendererIsExpanded obj val = liftIO $ B.Properties.setObjectPropertyBool obj "is-expanded" val {- | Construct a `GValueConstruct` with valid value for the “@is-expanded@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererIsExpanded :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o) constructCellRendererIsExpanded val = B.Properties.constructObjectPropertyBool "is-expanded" val #if ENABLE_OVERLOADING data CellRendererIsExpandedPropertyInfo instance AttrInfo CellRendererIsExpandedPropertyInfo where type AttrAllowedOps CellRendererIsExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererIsExpandedPropertyInfo = (~) Bool type AttrBaseTypeConstraint CellRendererIsExpandedPropertyInfo = IsCellRenderer type AttrGetType CellRendererIsExpandedPropertyInfo = Bool type AttrLabel CellRendererIsExpandedPropertyInfo = "is-expanded" type AttrOrigin CellRendererIsExpandedPropertyInfo = CellRenderer attrGet _ = getCellRendererIsExpanded attrSet _ = setCellRendererIsExpanded attrConstruct _ = constructCellRendererIsExpanded attrClear _ = undefined #endif -- VVV Prop "is-expander" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@is-expander@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #isExpander @ -} getCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> m Bool getCellRendererIsExpander obj = liftIO $ B.Properties.getObjectPropertyBool obj "is-expander" {- | Set the value of the “@is-expander@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #isExpander 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererIsExpander :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m () setCellRendererIsExpander obj val = liftIO $ B.Properties.setObjectPropertyBool obj "is-expander" val {- | Construct a `GValueConstruct` with valid value for the “@is-expander@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererIsExpander :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o) constructCellRendererIsExpander val = B.Properties.constructObjectPropertyBool "is-expander" val #if ENABLE_OVERLOADING data CellRendererIsExpanderPropertyInfo instance AttrInfo CellRendererIsExpanderPropertyInfo where type AttrAllowedOps CellRendererIsExpanderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererIsExpanderPropertyInfo = (~) Bool type AttrBaseTypeConstraint CellRendererIsExpanderPropertyInfo = IsCellRenderer type AttrGetType CellRendererIsExpanderPropertyInfo = Bool type AttrLabel CellRendererIsExpanderPropertyInfo = "is-expander" type AttrOrigin CellRendererIsExpanderPropertyInfo = CellRenderer attrGet _ = getCellRendererIsExpander attrSet _ = setCellRendererIsExpander attrConstruct _ = constructCellRendererIsExpander attrClear _ = undefined #endif -- VVV Prop "mode" -- Type: TInterface (Name {namespace = "Gtk", name = "CellRendererMode"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@mode@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #mode @ -} getCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> m Gtk.Enums.CellRendererMode getCellRendererMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "mode" {- | Set the value of the “@mode@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #mode 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererMode :: (MonadIO m, IsCellRenderer o) => o -> Gtk.Enums.CellRendererMode -> m () setCellRendererMode obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "mode" val {- | Construct a `GValueConstruct` with valid value for the “@mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererMode :: (IsCellRenderer o) => Gtk.Enums.CellRendererMode -> IO (GValueConstruct o) constructCellRendererMode val = B.Properties.constructObjectPropertyEnum "mode" val #if ENABLE_OVERLOADING data CellRendererModePropertyInfo instance AttrInfo CellRendererModePropertyInfo where type AttrAllowedOps CellRendererModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererModePropertyInfo = (~) Gtk.Enums.CellRendererMode type AttrBaseTypeConstraint CellRendererModePropertyInfo = IsCellRenderer type AttrGetType CellRendererModePropertyInfo = Gtk.Enums.CellRendererMode type AttrLabel CellRendererModePropertyInfo = "mode" type AttrOrigin CellRendererModePropertyInfo = CellRenderer attrGet _ = getCellRendererMode attrSet _ = setCellRendererMode attrConstruct _ = constructCellRendererMode attrClear _ = undefined #endif -- VVV Prop "sensitive" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@sensitive@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #sensitive @ -} getCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> m Bool getCellRendererSensitive obj = liftIO $ B.Properties.getObjectPropertyBool obj "sensitive" {- | Set the value of the “@sensitive@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #sensitive 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererSensitive :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m () setCellRendererSensitive obj val = liftIO $ B.Properties.setObjectPropertyBool obj "sensitive" val {- | Construct a `GValueConstruct` with valid value for the “@sensitive@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererSensitive :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o) constructCellRendererSensitive val = B.Properties.constructObjectPropertyBool "sensitive" val #if ENABLE_OVERLOADING data CellRendererSensitivePropertyInfo instance AttrInfo CellRendererSensitivePropertyInfo where type AttrAllowedOps CellRendererSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererSensitivePropertyInfo = (~) Bool type AttrBaseTypeConstraint CellRendererSensitivePropertyInfo = IsCellRenderer type AttrGetType CellRendererSensitivePropertyInfo = Bool type AttrLabel CellRendererSensitivePropertyInfo = "sensitive" type AttrOrigin CellRendererSensitivePropertyInfo = CellRenderer attrGet _ = getCellRendererSensitive attrSet _ = setCellRendererSensitive attrConstruct _ = constructCellRendererSensitive attrClear _ = undefined #endif -- VVV Prop "visible" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@visible@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #visible @ -} getCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> m Bool getCellRendererVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "visible" {- | Set the value of the “@visible@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #visible 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererVisible :: (MonadIO m, IsCellRenderer o) => o -> Bool -> m () setCellRendererVisible obj val = liftIO $ B.Properties.setObjectPropertyBool obj "visible" val {- | Construct a `GValueConstruct` with valid value for the “@visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererVisible :: (IsCellRenderer o) => Bool -> IO (GValueConstruct o) constructCellRendererVisible val = B.Properties.constructObjectPropertyBool "visible" val #if ENABLE_OVERLOADING data CellRendererVisiblePropertyInfo instance AttrInfo CellRendererVisiblePropertyInfo where type AttrAllowedOps CellRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererVisiblePropertyInfo = (~) Bool type AttrBaseTypeConstraint CellRendererVisiblePropertyInfo = IsCellRenderer type AttrGetType CellRendererVisiblePropertyInfo = Bool type AttrLabel CellRendererVisiblePropertyInfo = "visible" type AttrOrigin CellRendererVisiblePropertyInfo = CellRenderer attrGet _ = getCellRendererVisible attrSet _ = setCellRendererVisible attrConstruct _ = constructCellRendererVisible attrClear _ = undefined #endif -- VVV Prop "width" -- Type: TBasicType TInt -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@width@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #width @ -} getCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> m Int32 getCellRendererWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "width" {- | Set the value of the “@width@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #width 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererWidth :: (MonadIO m, IsCellRenderer o) => o -> Int32 -> m () setCellRendererWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "width" val {- | Construct a `GValueConstruct` with valid value for the “@width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererWidth :: (IsCellRenderer o) => Int32 -> IO (GValueConstruct o) constructCellRendererWidth val = B.Properties.constructObjectPropertyInt32 "width" val #if ENABLE_OVERLOADING data CellRendererWidthPropertyInfo instance AttrInfo CellRendererWidthPropertyInfo where type AttrAllowedOps CellRendererWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererWidthPropertyInfo = (~) Int32 type AttrBaseTypeConstraint CellRendererWidthPropertyInfo = IsCellRenderer type AttrGetType CellRendererWidthPropertyInfo = Int32 type AttrLabel CellRendererWidthPropertyInfo = "width" type AttrOrigin CellRendererWidthPropertyInfo = CellRenderer attrGet _ = getCellRendererWidth attrSet _ = setCellRendererWidth attrConstruct _ = constructCellRendererWidth attrClear _ = undefined #endif -- VVV Prop "xalign" -- Type: TBasicType TFloat -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@xalign@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #xalign @ -} getCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> m Float getCellRendererXalign obj = liftIO $ B.Properties.getObjectPropertyFloat obj "xalign" {- | Set the value of the “@xalign@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #xalign 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererXalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m () setCellRendererXalign obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "xalign" val {- | Construct a `GValueConstruct` with valid value for the “@xalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererXalign :: (IsCellRenderer o) => Float -> IO (GValueConstruct o) constructCellRendererXalign val = B.Properties.constructObjectPropertyFloat "xalign" val #if ENABLE_OVERLOADING data CellRendererXalignPropertyInfo instance AttrInfo CellRendererXalignPropertyInfo where type AttrAllowedOps CellRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererXalignPropertyInfo = (~) Float type AttrBaseTypeConstraint CellRendererXalignPropertyInfo = IsCellRenderer type AttrGetType CellRendererXalignPropertyInfo = Float type AttrLabel CellRendererXalignPropertyInfo = "xalign" type AttrOrigin CellRendererXalignPropertyInfo = CellRenderer attrGet _ = getCellRendererXalign attrSet _ = setCellRendererXalign attrConstruct _ = constructCellRendererXalign attrClear _ = undefined #endif -- VVV Prop "xpad" -- Type: TBasicType TUInt -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@xpad@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #xpad @ -} getCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32 getCellRendererXpad obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "xpad" {- | Set the value of the “@xpad@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #xpad 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererXpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m () setCellRendererXpad obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "xpad" val {- | Construct a `GValueConstruct` with valid value for the “@xpad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererXpad :: (IsCellRenderer o) => Word32 -> IO (GValueConstruct o) constructCellRendererXpad val = B.Properties.constructObjectPropertyUInt32 "xpad" val #if ENABLE_OVERLOADING data CellRendererXpadPropertyInfo instance AttrInfo CellRendererXpadPropertyInfo where type AttrAllowedOps CellRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererXpadPropertyInfo = (~) Word32 type AttrBaseTypeConstraint CellRendererXpadPropertyInfo = IsCellRenderer type AttrGetType CellRendererXpadPropertyInfo = Word32 type AttrLabel CellRendererXpadPropertyInfo = "xpad" type AttrOrigin CellRendererXpadPropertyInfo = CellRenderer attrGet _ = getCellRendererXpad attrSet _ = setCellRendererXpad attrConstruct _ = constructCellRendererXpad attrClear _ = undefined #endif -- VVV Prop "yalign" -- Type: TBasicType TFloat -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@yalign@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #yalign @ -} getCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> m Float getCellRendererYalign obj = liftIO $ B.Properties.getObjectPropertyFloat obj "yalign" {- | Set the value of the “@yalign@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #yalign 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererYalign :: (MonadIO m, IsCellRenderer o) => o -> Float -> m () setCellRendererYalign obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "yalign" val {- | Construct a `GValueConstruct` with valid value for the “@yalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererYalign :: (IsCellRenderer o) => Float -> IO (GValueConstruct o) constructCellRendererYalign val = B.Properties.constructObjectPropertyFloat "yalign" val #if ENABLE_OVERLOADING data CellRendererYalignPropertyInfo instance AttrInfo CellRendererYalignPropertyInfo where type AttrAllowedOps CellRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererYalignPropertyInfo = (~) Float type AttrBaseTypeConstraint CellRendererYalignPropertyInfo = IsCellRenderer type AttrGetType CellRendererYalignPropertyInfo = Float type AttrLabel CellRendererYalignPropertyInfo = "yalign" type AttrOrigin CellRendererYalignPropertyInfo = CellRenderer attrGet _ = getCellRendererYalign attrSet _ = setCellRendererYalign attrConstruct _ = constructCellRendererYalign attrClear _ = undefined #endif -- VVV Prop "ypad" -- Type: TBasicType TUInt -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@ypad@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' cellRenderer #ypad @ -} getCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> m Word32 getCellRendererYpad obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "ypad" {- | Set the value of the “@ypad@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' cellRenderer [ #ypad 'Data.GI.Base.Attributes.:=' value ] @ -} setCellRendererYpad :: (MonadIO m, IsCellRenderer o) => o -> Word32 -> m () setCellRendererYpad obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "ypad" val {- | Construct a `GValueConstruct` with valid value for the “@ypad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructCellRendererYpad :: (IsCellRenderer o) => Word32 -> IO (GValueConstruct o) constructCellRendererYpad val = B.Properties.constructObjectPropertyUInt32 "ypad" val #if ENABLE_OVERLOADING data CellRendererYpadPropertyInfo instance AttrInfo CellRendererYpadPropertyInfo where type AttrAllowedOps CellRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint CellRendererYpadPropertyInfo = (~) Word32 type AttrBaseTypeConstraint CellRendererYpadPropertyInfo = IsCellRenderer type AttrGetType CellRendererYpadPropertyInfo = Word32 type AttrLabel CellRendererYpadPropertyInfo = "ypad" type AttrOrigin CellRendererYpadPropertyInfo = CellRenderer attrGet _ = getCellRendererYpad attrSet _ = setCellRendererYpad attrConstruct _ = constructCellRendererYpad attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList CellRenderer type instance O.AttributeList CellRenderer = CellRendererAttributeList type CellRendererAttributeList = ('[ '("cellBackground", CellRendererCellBackgroundPropertyInfo), '("cellBackgroundGdk", CellRendererCellBackgroundGdkPropertyInfo), '("cellBackgroundRgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cellBackgroundSet", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("isExpanded", CellRendererIsExpandedPropertyInfo), '("isExpander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING cellRendererCellBackground :: AttrLabelProxy "cellBackground" cellRendererCellBackground = AttrLabelProxy cellRendererCellBackgroundGdk :: AttrLabelProxy "cellBackgroundGdk" cellRendererCellBackgroundGdk = AttrLabelProxy cellRendererCellBackgroundRgba :: AttrLabelProxy "cellBackgroundRgba" cellRendererCellBackgroundRgba = AttrLabelProxy cellRendererCellBackgroundSet :: AttrLabelProxy "cellBackgroundSet" cellRendererCellBackgroundSet = AttrLabelProxy cellRendererEditing :: AttrLabelProxy "editing" cellRendererEditing = AttrLabelProxy cellRendererHeight :: AttrLabelProxy "height" cellRendererHeight = AttrLabelProxy cellRendererIsExpanded :: AttrLabelProxy "isExpanded" cellRendererIsExpanded = AttrLabelProxy cellRendererIsExpander :: AttrLabelProxy "isExpander" cellRendererIsExpander = AttrLabelProxy cellRendererMode :: AttrLabelProxy "mode" cellRendererMode = AttrLabelProxy cellRendererSensitive :: AttrLabelProxy "sensitive" cellRendererSensitive = AttrLabelProxy cellRendererVisible :: AttrLabelProxy "visible" cellRendererVisible = AttrLabelProxy cellRendererWidth :: AttrLabelProxy "width" cellRendererWidth = AttrLabelProxy cellRendererXalign :: AttrLabelProxy "xalign" cellRendererXalign = AttrLabelProxy cellRendererXpad :: AttrLabelProxy "xpad" cellRendererXpad = AttrLabelProxy cellRendererYalign :: AttrLabelProxy "yalign" cellRendererYalign = AttrLabelProxy cellRendererYpad :: AttrLabelProxy "ypad" cellRendererYpad = AttrLabelProxy #endif #if ENABLE_OVERLOADING data CellRendererEditingCanceledSignalInfo instance SignalInfo CellRendererEditingCanceledSignalInfo where type HaskellCallbackType CellRendererEditingCanceledSignalInfo = CellRendererEditingCanceledCallback connectSignal _ obj cb connectMode = do let cb' = wrap_CellRendererEditingCanceledCallback cb cb'' <- mk_CellRendererEditingCanceledCallback cb' connectSignalFunPtr obj "editing-canceled" cb'' connectMode data CellRendererEditingStartedSignalInfo instance SignalInfo CellRendererEditingStartedSignalInfo where type HaskellCallbackType CellRendererEditingStartedSignalInfo = CellRendererEditingStartedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_CellRendererEditingStartedCallback cb cb'' <- mk_CellRendererEditingStartedCallback cb' connectSignalFunPtr obj "editing-started" cb'' connectMode type instance O.SignalList CellRenderer = CellRendererSignalList type CellRendererSignalList = ('[ '("editingCanceled", CellRendererEditingCanceledSignalInfo), '("editingStarted", CellRendererEditingStartedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method CellRenderer::activate -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget that received the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget-dependent string representation of the event location;\n e.g. for #GtkTreeView, a string representation of #GtkTreePath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "background area as passed to gtk_cell_renderer_render()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cell area as passed to gtk_cell_renderer_render()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "CellRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "render flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_activate" gtk_cell_renderer_activate :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gdk.Event.Event -> -- event : TInterface (Name {namespace = "Gdk", name = "Event"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) CString -> -- path : TBasicType TUTF8 Ptr Gdk.Rectangle.Rectangle -> -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) Ptr Gdk.Rectangle.Rectangle -> -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) CUInt -> -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"}) IO CInt {- | Passes an activate event to the cell renderer for possible processing. Some cell renderers may use events; for example, 'GI.Gtk.Objects.CellRendererToggle.CellRendererToggle' toggles when it gets a mouse click. -} cellRendererActivate :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Gdk.Event.Event {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' -} -> b {- ^ /@widget@/: widget that received the event -} -> T.Text {- ^ /@path@/: widget-dependent string representation of the event location; e.g. for 'GI.Gtk.Objects.TreeView.TreeView', a string representation of 'GI.Gtk.Structs.TreePath.TreePath' -} -> Gdk.Rectangle.Rectangle {- ^ /@backgroundArea@/: background area as passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender' -} -> Gdk.Rectangle.Rectangle {- ^ /@cellArea@/: cell area as passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender' -} -> [Gtk.Flags.CellRendererState] {- ^ /@flags@/: render flags -} -> m Bool {- ^ __Returns:__ 'True' if the event was consumed\/handled -} cellRendererActivate cell event widget path backgroundArea cellArea flags = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell event' <- unsafeManagedPtrGetPtr event widget' <- unsafeManagedPtrCastPtr widget path' <- textToCString path backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea cellArea' <- unsafeManagedPtrGetPtr cellArea let flags' = gflagsToWord flags result <- gtk_cell_renderer_activate cell' event' widget' path' backgroundArea' cellArea' flags' let result' = (/= 0) result touchManagedPtr cell touchManagedPtr event touchManagedPtr widget touchManagedPtr backgroundArea touchManagedPtr cellArea freeMem path' return result' #if ENABLE_OVERLOADING data CellRendererActivateMethodInfo instance (signature ~ (Gdk.Event.Event -> b -> T.Text -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> [Gtk.Flags.CellRendererState] -> m Bool), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererActivateMethodInfo a signature where overloadedMethod _ = cellRendererActivate #endif -- method CellRenderer::get_aligned_area -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkWidget this cell will be rendering to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "CellRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "render flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cell area which would be passed to gtk_cell_renderer_render()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "aligned_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the return location for the space inside @cell_area\n that would acually be used to render.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_aligned_area" gtk_cell_renderer_get_aligned_area :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) CUInt -> -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"}) Ptr Gdk.Rectangle.Rectangle -> -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) Ptr Gdk.Rectangle.Rectangle -> -- aligned_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) IO () {- | Gets the aligned area used by /@cell@/ inside /@cellArea@/. Used for finding the appropriate edit and focus rectangle. /Since: 3.0/ -} cellRendererGetAlignedArea :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -} -> b {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -} -> [Gtk.Flags.CellRendererState] {- ^ /@flags@/: render flags -} -> Gdk.Rectangle.Rectangle {- ^ /@cellArea@/: cell area which would be passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender' -} -> m (Gdk.Rectangle.Rectangle) cellRendererGetAlignedArea cell widget flags cellArea = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell widget' <- unsafeManagedPtrCastPtr widget let flags' = gflagsToWord flags cellArea' <- unsafeManagedPtrGetPtr cellArea alignedArea <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle) gtk_cell_renderer_get_aligned_area cell' widget' flags' cellArea' alignedArea alignedArea' <- (wrapBoxed Gdk.Rectangle.Rectangle) alignedArea touchManagedPtr cell touchManagedPtr widget touchManagedPtr cellArea return alignedArea' #if ENABLE_OVERLOADING data CellRendererGetAlignedAreaMethodInfo instance (signature ~ (b -> [Gtk.Flags.CellRendererState] -> Gdk.Rectangle.Rectangle -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetAlignedAreaMethodInfo a signature where overloadedMethod _ = cellRendererGetAlignedArea #endif -- method CellRenderer::get_alignment -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to fill in with the x alignment of the cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "yalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to fill in with the y alignment of the cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_alignment" gtk_cell_renderer_get_alignment :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr CFloat -> -- xalign : TBasicType TFloat Ptr CFloat -> -- yalign : TBasicType TFloat IO () {- | Fills in /@xalign@/ and /@yalign@/ with the appropriate values of /@cell@/. /Since: 2.18/ -} cellRendererGetAlignment :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> m ((Float, Float)) cellRendererGetAlignment cell = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell xalign <- allocMem :: IO (Ptr CFloat) yalign <- allocMem :: IO (Ptr CFloat) gtk_cell_renderer_get_alignment cell' xalign yalign xalign' <- peek xalign let xalign'' = realToFrac xalign' yalign' <- peek yalign let yalign'' = realToFrac yalign' touchManagedPtr cell freeMem xalign freeMem yalign return (xalign'', yalign'') #if ENABLE_OVERLOADING data CellRendererGetAlignmentMethodInfo instance (signature ~ (m ((Float, Float))), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetAlignmentMethodInfo a signature where overloadedMethod _ = cellRendererGetAlignment #endif -- method CellRenderer::get_fixed_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to fill in with the fixed width of the cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to fill in with the fixed height of the cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_fixed_size" gtk_cell_renderer_get_fixed_size :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Int32 -> -- width : TBasicType TInt Ptr Int32 -> -- height : TBasicType TInt IO () {- | Fills in /@width@/ and /@height@/ with the appropriate size of /@cell@/. -} cellRendererGetFixedSize :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> m ((Int32, Int32)) cellRendererGetFixedSize cell = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell width <- allocMem :: IO (Ptr Int32) height <- allocMem :: IO (Ptr Int32) gtk_cell_renderer_get_fixed_size cell' width height width' <- peek width height' <- peek height touchManagedPtr cell freeMem width freeMem height return (width', height') #if ENABLE_OVERLOADING data CellRendererGetFixedSizeMethodInfo instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetFixedSizeMethodInfo a signature where overloadedMethod _ = cellRendererGetFixedSize #endif -- method CellRenderer::get_padding -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xpad", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to fill in with the x padding of the cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "ypad", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to fill in with the y padding of the cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_padding" gtk_cell_renderer_get_padding :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Int32 -> -- xpad : TBasicType TInt Ptr Int32 -> -- ypad : TBasicType TInt IO () {- | Fills in /@xpad@/ and /@ypad@/ with the appropriate values of /@cell@/. /Since: 2.18/ -} cellRendererGetPadding :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> m ((Int32, Int32)) cellRendererGetPadding cell = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell xpad <- allocMem :: IO (Ptr Int32) ypad <- allocMem :: IO (Ptr Int32) gtk_cell_renderer_get_padding cell' xpad ypad xpad' <- peek xpad ypad' <- peek ypad touchManagedPtr cell freeMem xpad freeMem ypad return (xpad', ypad') #if ENABLE_OVERLOADING data CellRendererGetPaddingMethodInfo instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetPaddingMethodInfo a signature where overloadedMethod _ = cellRendererGetPadding #endif -- method CellRenderer::get_preferred_height -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkWidget this cell will be rendering to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_size", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the minimum size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_size", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the natural size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_preferred_height" gtk_cell_renderer_get_preferred_height :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) Ptr Int32 -> -- minimum_size : TBasicType TInt Ptr Int32 -> -- natural_size : TBasicType TInt IO () {- | Retreives a renderer’s natural size when rendered to /@widget@/. /Since: 3.0/ -} cellRendererGetPreferredHeight :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -} -> b {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -} -> m ((Int32, Int32)) cellRendererGetPreferredHeight cell widget = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell widget' <- unsafeManagedPtrCastPtr widget minimumSize <- allocMem :: IO (Ptr Int32) naturalSize <- allocMem :: IO (Ptr Int32) gtk_cell_renderer_get_preferred_height cell' widget' minimumSize naturalSize minimumSize' <- peek minimumSize naturalSize' <- peek naturalSize touchManagedPtr cell touchManagedPtr widget freeMem minimumSize freeMem naturalSize return (minimumSize', naturalSize') #if ENABLE_OVERLOADING data CellRendererGetPreferredHeightMethodInfo instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredHeightMethodInfo a signature where overloadedMethod _ = cellRendererGetPreferredHeight #endif -- method CellRenderer::get_preferred_height_for_width -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkWidget this cell will be rendering to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size which is available for allocation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the minimum size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the preferred size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_preferred_height_for_width" gtk_cell_renderer_get_preferred_height_for_width :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) Int32 -> -- width : TBasicType TInt Ptr Int32 -> -- minimum_height : TBasicType TInt Ptr Int32 -> -- natural_height : TBasicType TInt IO () {- | Retreives a cell renderers’s minimum and natural height if it were rendered to /@widget@/ with the specified /@width@/. /Since: 3.0/ -} cellRendererGetPreferredHeightForWidth :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -} -> b {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -} -> Int32 {- ^ /@width@/: the size which is available for allocation -} -> m ((Int32, Int32)) cellRendererGetPreferredHeightForWidth cell widget width = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell widget' <- unsafeManagedPtrCastPtr widget minimumHeight <- allocMem :: IO (Ptr Int32) naturalHeight <- allocMem :: IO (Ptr Int32) gtk_cell_renderer_get_preferred_height_for_width cell' widget' width minimumHeight naturalHeight minimumHeight' <- peek minimumHeight naturalHeight' <- peek naturalHeight touchManagedPtr cell touchManagedPtr widget freeMem minimumHeight freeMem naturalHeight return (minimumHeight', naturalHeight') #if ENABLE_OVERLOADING data CellRendererGetPreferredHeightForWidthMethodInfo instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredHeightForWidthMethodInfo a signature where overloadedMethod _ = cellRendererGetPreferredHeightForWidth #endif -- method CellRenderer::get_preferred_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkWidget this cell will be rendering to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_size", argType = TInterface (Name {namespace = "Gtk", name = "Requisition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the minimum size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "natural_size", argType = TInterface (Name {namespace = "Gtk", name = "Requisition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the natural size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_preferred_size" gtk_cell_renderer_get_preferred_size :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) Ptr Gtk.Requisition.Requisition -> -- minimum_size : TInterface (Name {namespace = "Gtk", name = "Requisition"}) Ptr Gtk.Requisition.Requisition -> -- natural_size : TInterface (Name {namespace = "Gtk", name = "Requisition"}) IO () {- | Retrieves the minimum and natural size of a cell taking into account the widget’s preference for height-for-width management. /Since: 3.0/ -} cellRendererGetPreferredSize :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -} -> b {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -} -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition)) cellRendererGetPreferredSize cell widget = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell widget' <- unsafeManagedPtrCastPtr widget minimumSize <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition) naturalSize <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition) gtk_cell_renderer_get_preferred_size cell' widget' minimumSize naturalSize minimumSize' <- (wrapBoxed Gtk.Requisition.Requisition) minimumSize naturalSize' <- (wrapBoxed Gtk.Requisition.Requisition) naturalSize touchManagedPtr cell touchManagedPtr widget return (minimumSize', naturalSize') #if ENABLE_OVERLOADING data CellRendererGetPreferredSizeMethodInfo instance (signature ~ (b -> m ((Gtk.Requisition.Requisition, Gtk.Requisition.Requisition))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredSizeMethodInfo a signature where overloadedMethod _ = cellRendererGetPreferredSize #endif -- method CellRenderer::get_preferred_width -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkWidget this cell will be rendering to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_size", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the minimum size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_size", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the natural size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_preferred_width" gtk_cell_renderer_get_preferred_width :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) Ptr Int32 -> -- minimum_size : TBasicType TInt Ptr Int32 -> -- natural_size : TBasicType TInt IO () {- | Retreives a renderer’s natural size when rendered to /@widget@/. /Since: 3.0/ -} cellRendererGetPreferredWidth :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -} -> b {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -} -> m ((Int32, Int32)) cellRendererGetPreferredWidth cell widget = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell widget' <- unsafeManagedPtrCastPtr widget minimumSize <- allocMem :: IO (Ptr Int32) naturalSize <- allocMem :: IO (Ptr Int32) gtk_cell_renderer_get_preferred_width cell' widget' minimumSize naturalSize minimumSize' <- peek minimumSize naturalSize' <- peek naturalSize touchManagedPtr cell touchManagedPtr widget freeMem minimumSize freeMem naturalSize return (minimumSize', naturalSize') #if ENABLE_OVERLOADING data CellRendererGetPreferredWidthMethodInfo instance (signature ~ (b -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredWidthMethodInfo a signature where overloadedMethod _ = cellRendererGetPreferredWidth #endif -- method CellRenderer::get_preferred_width_for_height -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkWidget this cell will be rendering to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size which is available for allocation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the minimum size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the preferred size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_preferred_width_for_height" gtk_cell_renderer_get_preferred_width_for_height :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) Int32 -> -- height : TBasicType TInt Ptr Int32 -> -- minimum_width : TBasicType TInt Ptr Int32 -> -- natural_width : TBasicType TInt IO () {- | Retreives a cell renderers’s minimum and natural width if it were rendered to /@widget@/ with the specified /@height@/. /Since: 3.0/ -} cellRendererGetPreferredWidthForHeight :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -} -> b {- ^ /@widget@/: the 'GI.Gtk.Objects.Widget.Widget' this cell will be rendering to -} -> Int32 {- ^ /@height@/: the size which is available for allocation -} -> m ((Int32, Int32)) cellRendererGetPreferredWidthForHeight cell widget height = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell widget' <- unsafeManagedPtrCastPtr widget minimumWidth <- allocMem :: IO (Ptr Int32) naturalWidth <- allocMem :: IO (Ptr Int32) gtk_cell_renderer_get_preferred_width_for_height cell' widget' height minimumWidth naturalWidth minimumWidth' <- peek minimumWidth naturalWidth' <- peek naturalWidth touchManagedPtr cell touchManagedPtr widget freeMem minimumWidth freeMem naturalWidth return (minimumWidth', naturalWidth') #if ENABLE_OVERLOADING data CellRendererGetPreferredWidthForHeightMethodInfo instance (signature ~ (b -> Int32 -> m ((Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetPreferredWidthForHeightMethodInfo a signature where overloadedMethod _ = cellRendererGetPreferredWidthForHeight #endif -- method CellRenderer::get_request_mode -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "SizeRequestMode"})) -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_request_mode" gtk_cell_renderer_get_request_mode :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) IO CUInt {- | Gets whether the cell renderer prefers a height-for-width layout or a width-for-height layout. /Since: 3.0/ -} cellRendererGetRequestMode :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' instance -} -> m Gtk.Enums.SizeRequestMode {- ^ __Returns:__ The 'GI.Gtk.Enums.SizeRequestMode' preferred by this renderer. -} cellRendererGetRequestMode cell = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell result <- gtk_cell_renderer_get_request_mode cell' let result' = (toEnum . fromIntegral) result touchManagedPtr cell return result' #if ENABLE_OVERLOADING data CellRendererGetRequestModeMethodInfo instance (signature ~ (m Gtk.Enums.SizeRequestMode), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetRequestModeMethodInfo a signature where overloadedMethod _ = cellRendererGetRequestMode #endif -- method CellRenderer::get_sensitive -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_sensitive" gtk_cell_renderer_get_sensitive :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) IO CInt {- | Returns the cell renderer’s sensitivity. /Since: 2.18/ -} cellRendererGetSensitive :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> m Bool {- ^ __Returns:__ 'True' if the cell renderer is sensitive -} cellRendererGetSensitive cell = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell result <- gtk_cell_renderer_get_sensitive cell' let result' = (/= 0) result touchManagedPtr cell return result' #if ENABLE_OVERLOADING data CellRendererGetSensitiveMethodInfo instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetSensitiveMethodInfo a signature where overloadedMethod _ = cellRendererGetSensitive #endif -- method CellRenderer::get_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget the renderer is rendering to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The area a cell will be allocated, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_offset", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return x offset of cell relative to @cell_area, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y_offset", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return y offset of cell relative to @cell_area, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return width needed to render a cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return height needed to render a cell, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_size" gtk_cell_renderer_get_size :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) Ptr Gdk.Rectangle.Rectangle -> -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) Ptr Int32 -> -- x_offset : TBasicType TInt Ptr Int32 -> -- y_offset : TBasicType TInt Ptr Int32 -> -- width : TBasicType TInt Ptr Int32 -> -- height : TBasicType TInt IO () {-# DEPRECATED cellRendererGetSize ["(Since version 3.0)","Use 'GI.Gtk.Objects.CellRenderer.cellRendererGetPreferredSize' instead."] #-} {- | Obtains the width and height needed to render the cell. Used by view widgets to determine the appropriate size for the cell_area passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender'. If /@cellArea@/ is not 'Nothing', fills in the x and y offsets (if set) of the cell relative to this location. Please note that the values set in /@width@/ and /@height@/, as well as those in /@xOffset@/ and /@yOffset@/ are inclusive of the xpad and ypad properties. -} cellRendererGetSize :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> b {- ^ /@widget@/: the widget the renderer is rendering to -} -> Maybe (Gdk.Rectangle.Rectangle) {- ^ /@cellArea@/: The area a cell will be allocated, or 'Nothing' -} -> m ((Int32, Int32, Int32, Int32)) cellRendererGetSize cell widget cellArea = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell widget' <- unsafeManagedPtrCastPtr widget maybeCellArea <- case cellArea of Nothing -> return nullPtr Just jCellArea -> do jCellArea' <- unsafeManagedPtrGetPtr jCellArea return jCellArea' xOffset <- allocMem :: IO (Ptr Int32) yOffset <- allocMem :: IO (Ptr Int32) width <- allocMem :: IO (Ptr Int32) height <- allocMem :: IO (Ptr Int32) gtk_cell_renderer_get_size cell' widget' maybeCellArea xOffset yOffset width height xOffset' <- peek xOffset yOffset' <- peek yOffset width' <- peek width height' <- peek height touchManagedPtr cell touchManagedPtr widget whenJust cellArea touchManagedPtr freeMem xOffset freeMem yOffset freeMem width freeMem height return (xOffset', yOffset', width', height') #if ENABLE_OVERLOADING data CellRendererGetSizeMethodInfo instance (signature ~ (b -> Maybe (Gdk.Rectangle.Rectangle) -> m ((Int32, Int32, Int32, Int32))), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetSizeMethodInfo a signature where overloadedMethod _ = cellRendererGetSize #endif -- method CellRenderer::get_state -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkWidget, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_state", argType = TInterface (Name {namespace = "Gtk", name = "CellRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cell renderer state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "StateFlags"})) -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_state" gtk_cell_renderer_get_state :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) CUInt -> -- cell_state : TInterface (Name {namespace = "Gtk", name = "CellRendererState"}) IO CUInt {- | Translates the cell renderer state to 'GI.Gtk.Flags.StateFlags', based on the cell renderer and widget sensitivity, and the given 'GI.Gtk.Flags.CellRendererState'. /Since: 3.0/ -} cellRendererGetState :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer', or 'Nothing' -} -> Maybe (b) {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget', or 'Nothing' -} -> [Gtk.Flags.CellRendererState] {- ^ /@cellState@/: cell renderer state -} -> m [Gtk.Flags.StateFlags] {- ^ __Returns:__ the widget state flags applying to /@cell@/ -} cellRendererGetState cell widget cellState = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell maybeWidget <- case widget of Nothing -> return nullPtr Just jWidget -> do jWidget' <- unsafeManagedPtrCastPtr jWidget return jWidget' let cellState' = gflagsToWord cellState result <- gtk_cell_renderer_get_state cell' maybeWidget cellState' let result' = wordToGFlags result touchManagedPtr cell whenJust widget touchManagedPtr return result' #if ENABLE_OVERLOADING data CellRendererGetStateMethodInfo instance (signature ~ (Maybe (b) -> [Gtk.Flags.CellRendererState] -> m [Gtk.Flags.StateFlags]), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererGetStateMethodInfo a signature where overloadedMethod _ = cellRendererGetState #endif -- method CellRenderer::get_visible -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_get_visible" gtk_cell_renderer_get_visible :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) IO CInt {- | Returns the cell renderer’s visibility. /Since: 2.18/ -} cellRendererGetVisible :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> m Bool {- ^ __Returns:__ 'True' if the cell renderer is visible -} cellRendererGetVisible cell = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell result <- gtk_cell_renderer_get_visible cell' let result' = (/= 0) result touchManagedPtr cell return result' #if ENABLE_OVERLOADING data CellRendererGetVisibleMethodInfo instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererGetVisibleMethodInfo a signature where overloadedMethod _ = cellRendererGetVisible #endif -- method CellRenderer::is_activatable -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_is_activatable" gtk_cell_renderer_is_activatable :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) IO CInt {- | Checks whether the cell renderer can do something when activated. /Since: 3.0/ -} cellRendererIsActivatable :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> m Bool {- ^ __Returns:__ 'True' if the cell renderer can do anything when activated -} cellRendererIsActivatable cell = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell result <- gtk_cell_renderer_is_activatable cell' let result' = (/= 0) result touchManagedPtr cell return result' #if ENABLE_OVERLOADING data CellRendererIsActivatableMethodInfo instance (signature ~ (m Bool), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererIsActivatableMethodInfo a signature where overloadedMethod _ = cellRendererIsActivatable #endif -- method CellRenderer::render -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cr", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a cairo context to draw to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget owning @window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "entire cell area (including tree expanders and maybe\n padding on the sides)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "area normally rendered by a cell renderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "CellRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags that affect rendering", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_render" gtk_cell_renderer_render :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Cairo.Context.Context -> -- cr : TInterface (Name {namespace = "cairo", name = "Context"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) Ptr Gdk.Rectangle.Rectangle -> -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) Ptr Gdk.Rectangle.Rectangle -> -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) CUInt -> -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"}) IO () {- | Invokes the virtual render function of the 'GI.Gtk.Objects.CellRenderer.CellRenderer'. The three passed-in rectangles are areas in /@cr@/. Most renderers will draw within /@cellArea@/; the xalign, yalign, xpad, and ypad fields of the 'GI.Gtk.Objects.CellRenderer.CellRenderer' should be honored with respect to /@cellArea@/. /@backgroundArea@/ includes the blank space around the cell, and also the area containing the tree expander; so the /@backgroundArea@/ rectangles for all cells tile to cover the entire /@window@/. -} cellRendererRender :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Cairo.Context.Context {- ^ /@cr@/: a cairo context to draw to -} -> b {- ^ /@widget@/: the widget owning /@window@/ -} -> Gdk.Rectangle.Rectangle {- ^ /@backgroundArea@/: entire cell area (including tree expanders and maybe padding on the sides) -} -> Gdk.Rectangle.Rectangle {- ^ /@cellArea@/: area normally rendered by a cell renderer -} -> [Gtk.Flags.CellRendererState] {- ^ /@flags@/: flags that affect rendering -} -> m () cellRendererRender cell cr widget backgroundArea cellArea flags = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell cr' <- unsafeManagedPtrGetPtr cr widget' <- unsafeManagedPtrCastPtr widget backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea cellArea' <- unsafeManagedPtrGetPtr cellArea let flags' = gflagsToWord flags gtk_cell_renderer_render cell' cr' widget' backgroundArea' cellArea' flags' touchManagedPtr cell touchManagedPtr cr touchManagedPtr widget touchManagedPtr backgroundArea touchManagedPtr cellArea return () #if ENABLE_OVERLOADING data CellRendererRenderMethodInfo instance (signature ~ (Cairo.Context.Context -> b -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> [Gtk.Flags.CellRendererState] -> m ()), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererRenderMethodInfo a signature where overloadedMethod _ = cellRendererRender #endif -- method CellRenderer::set_alignment -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x alignment of the cell renderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y alignment of the cell renderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_set_alignment" gtk_cell_renderer_set_alignment :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) CFloat -> -- xalign : TBasicType TFloat CFloat -> -- yalign : TBasicType TFloat IO () {- | Sets the renderer’s alignment within its available space. /Since: 2.18/ -} cellRendererSetAlignment :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Float {- ^ /@xalign@/: the x alignment of the cell renderer -} -> Float {- ^ /@yalign@/: the y alignment of the cell renderer -} -> m () cellRendererSetAlignment cell xalign yalign = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell let xalign' = realToFrac xalign let yalign' = realToFrac yalign gtk_cell_renderer_set_alignment cell' xalign' yalign' touchManagedPtr cell return () #if ENABLE_OVERLOADING data CellRendererSetAlignmentMethodInfo instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererSetAlignmentMethodInfo a signature where overloadedMethod _ = cellRendererSetAlignment #endif -- method CellRenderer::set_fixed_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of the cell renderer, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of the cell renderer, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_set_fixed_size" gtk_cell_renderer_set_fixed_size :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Int32 -> -- width : TBasicType TInt Int32 -> -- height : TBasicType TInt IO () {- | Sets the renderer size to be explicit, independent of the properties set. -} cellRendererSetFixedSize :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Int32 {- ^ /@width@/: the width of the cell renderer, or -1 -} -> Int32 {- ^ /@height@/: the height of the cell renderer, or -1 -} -> m () cellRendererSetFixedSize cell width height = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell gtk_cell_renderer_set_fixed_size cell' width height touchManagedPtr cell return () #if ENABLE_OVERLOADING data CellRendererSetFixedSizeMethodInfo instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererSetFixedSizeMethodInfo a signature where overloadedMethod _ = cellRendererSetFixedSize #endif -- method CellRenderer::set_padding -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xpad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x padding of the cell renderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ypad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y padding of the cell renderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_set_padding" gtk_cell_renderer_set_padding :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Int32 -> -- xpad : TBasicType TInt Int32 -> -- ypad : TBasicType TInt IO () {- | Sets the renderer’s padding. /Since: 2.18/ -} cellRendererSetPadding :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Int32 {- ^ /@xpad@/: the x padding of the cell renderer -} -> Int32 {- ^ /@ypad@/: the y padding of the cell renderer -} -> m () cellRendererSetPadding cell xpad ypad = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell gtk_cell_renderer_set_padding cell' xpad ypad touchManagedPtr cell return () #if ENABLE_OVERLOADING data CellRendererSetPaddingMethodInfo instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererSetPaddingMethodInfo a signature where overloadedMethod _ = cellRendererSetPadding #endif -- method CellRenderer::set_sensitive -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the sensitivity of the cell", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_set_sensitive" gtk_cell_renderer_set_sensitive :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) CInt -> -- sensitive : TBasicType TBoolean IO () {- | Sets the cell renderer’s sensitivity. /Since: 2.18/ -} cellRendererSetSensitive :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Bool {- ^ /@sensitive@/: the sensitivity of the cell -} -> m () cellRendererSetSensitive cell sensitive = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell let sensitive' = (fromIntegral . fromEnum) sensitive gtk_cell_renderer_set_sensitive cell' sensitive' touchManagedPtr cell return () #if ENABLE_OVERLOADING data CellRendererSetSensitiveMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererSetSensitiveMethodInfo a signature where overloadedMethod _ = cellRendererSetSensitive #endif -- method CellRenderer::set_visible -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the visibility of the cell", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_set_visible" gtk_cell_renderer_set_visible :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) CInt -> -- visible : TBasicType TBoolean IO () {- | Sets the cell renderer’s visibility. /Since: 2.18/ -} cellRendererSetVisible :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Bool {- ^ /@visible@/: the visibility of the cell -} -> m () cellRendererSetVisible cell visible = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell let visible' = (fromIntegral . fromEnum) visible gtk_cell_renderer_set_visible cell' visible' touchManagedPtr cell return () #if ENABLE_OVERLOADING data CellRendererSetVisibleMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererSetVisibleMethodInfo a signature where overloadedMethod _ = cellRendererSetVisible #endif -- method CellRenderer::start_editing -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GdkEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget that received the event", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget-dependent string representation of the event location;\n e.g. for #GtkTreeView, a string representation of #GtkTreePath", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "background area as passed to gtk_cell_renderer_render()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cell area as passed to gtk_cell_renderer_render()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "CellRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "render flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "CellEditable"})) -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_start_editing" gtk_cell_renderer_start_editing :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) Ptr Gdk.Event.Event -> -- event : TInterface (Name {namespace = "Gdk", name = "Event"}) Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) CString -> -- path : TBasicType TUTF8 Ptr Gdk.Rectangle.Rectangle -> -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) Ptr Gdk.Rectangle.Rectangle -> -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) CUInt -> -- flags : TInterface (Name {namespace = "Gtk", name = "CellRendererState"}) IO (Ptr Gtk.CellEditable.CellEditable) {- | Starts editing the contents of this /@cell@/, through a new 'GI.Gtk.Interfaces.CellEditable.CellEditable' widget created by the 'GI.Gtk.Structs.CellRendererClass.CellRendererClass'.@/start_editing/@ virtual function. -} cellRendererStartEditing :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => a {- ^ /@cell@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Maybe (Gdk.Event.Event) {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' -} -> b {- ^ /@widget@/: widget that received the event -} -> T.Text {- ^ /@path@/: widget-dependent string representation of the event location; e.g. for 'GI.Gtk.Objects.TreeView.TreeView', a string representation of 'GI.Gtk.Structs.TreePath.TreePath' -} -> Gdk.Rectangle.Rectangle {- ^ /@backgroundArea@/: background area as passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender' -} -> Gdk.Rectangle.Rectangle {- ^ /@cellArea@/: cell area as passed to 'GI.Gtk.Objects.CellRenderer.cellRendererRender' -} -> [Gtk.Flags.CellRendererState] {- ^ /@flags@/: render flags -} -> m (Maybe Gtk.CellEditable.CellEditable) {- ^ __Returns:__ A new 'GI.Gtk.Interfaces.CellEditable.CellEditable' for editing this /@cell@/, or 'Nothing' if editing is not possible -} cellRendererStartEditing cell event widget path backgroundArea cellArea flags = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell maybeEvent <- case event of Nothing -> return nullPtr Just jEvent -> do jEvent' <- unsafeManagedPtrGetPtr jEvent return jEvent' widget' <- unsafeManagedPtrCastPtr widget path' <- textToCString path backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea cellArea' <- unsafeManagedPtrGetPtr cellArea let flags' = gflagsToWord flags result <- gtk_cell_renderer_start_editing cell' maybeEvent widget' path' backgroundArea' cellArea' flags' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject Gtk.CellEditable.CellEditable) result' return result'' touchManagedPtr cell whenJust event touchManagedPtr touchManagedPtr widget touchManagedPtr backgroundArea touchManagedPtr cellArea freeMem path' return maybeResult #if ENABLE_OVERLOADING data CellRendererStartEditingMethodInfo instance (signature ~ (Maybe (Gdk.Event.Event) -> b -> T.Text -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> [Gtk.Flags.CellRendererState] -> m (Maybe Gtk.CellEditable.CellEditable)), MonadIO m, IsCellRenderer a, Gtk.Widget.IsWidget b) => O.MethodInfo CellRendererStartEditingMethodInfo a signature where overloadedMethod _ = cellRendererStartEditing #endif -- method CellRenderer::stop_editing -- method type : OrdinaryMethod -- Args : [Arg {argCName = "cell", argType = TInterface (Name {namespace = "Gtk", name = "CellRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkCellRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "canceled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the editing has been canceled", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_cell_renderer_stop_editing" gtk_cell_renderer_stop_editing :: Ptr CellRenderer -> -- cell : TInterface (Name {namespace = "Gtk", name = "CellRenderer"}) CInt -> -- canceled : TBasicType TBoolean IO () {- | Informs the cell renderer that the editing is stopped. If /@canceled@/ is 'True', the cell renderer will emit the 'GI.Gtk.Objects.CellRenderer.CellRenderer'::@/editing-canceled/@ signal. This function should be called by cell renderer implementations in response to the 'GI.Gtk.Interfaces.CellEditable.CellEditable'::@/editing-done/@ signal of 'GI.Gtk.Interfaces.CellEditable.CellEditable'. /Since: 2.6/ -} cellRendererStopEditing :: (B.CallStack.HasCallStack, MonadIO m, IsCellRenderer a) => a {- ^ /@cell@/: A 'GI.Gtk.Objects.CellRenderer.CellRenderer' -} -> Bool {- ^ /@canceled@/: 'True' if the editing has been canceled -} -> m () cellRendererStopEditing cell canceled = liftIO $ do cell' <- unsafeManagedPtrCastPtr cell let canceled' = (fromIntegral . fromEnum) canceled gtk_cell_renderer_stop_editing cell' canceled' touchManagedPtr cell return () #if ENABLE_OVERLOADING data CellRendererStopEditingMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsCellRenderer a) => O.MethodInfo CellRendererStopEditingMethodInfo a signature where overloadedMethod _ = cellRendererStopEditing #endif