Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria |
Safe Haskell | None |
Language | Haskell2010 |
- Methods
- accelGroupsActivate
- accelGroupsFromObject
- acceleratorGetDefaultModMask
- acceleratorGetLabel
- acceleratorGetLabelWithKeycode
- acceleratorName
- acceleratorNameWithKeycode
- acceleratorParse
- acceleratorParseWithKeycode
- acceleratorSetDefaultModMask
- acceleratorValid
- bindingsActivate
- bindingsActivateEvent
- checkVersion
- contentFormatsAddImageTargets
- contentFormatsAddTextTargets
- contentFormatsAddUriTargets
- deviceGrabAdd
- deviceGrabRemove
- disableSetlocale
- distributeNaturalAllocation
- dragCancel
- dragGetSourceWidget
- dragSetIconDefault
- dragSetIconGicon
- dragSetIconName
- dragSetIconPaintable
- dragSetIconWidget
- eventsPending
- getBinaryAge
- getCurrentEvent
- getCurrentEventDevice
- getCurrentEventState
- getCurrentEventTime
- getDebugFlags
- getDefaultLanguage
- getEventTarget
- getEventTargetWithType
- getEventWidget
- getInterfaceAge
- getLocaleDirection
- getMainThread
- getMajorVersion
- getMicroVersion
- getMinorVersion
- grabGetCurrent
- hsvToRgb
- imModulesInit
- init
- initCheck
- isInitialized
- main
- mainDoEvent
- mainIteration
- mainIterationDo
- mainLevel
- mainQuit
- printRunPageSetupDialog
- printRunPageSetupDialogAsync
- propagateEvent
- rcPropertyParseBorder
- rcPropertyParseColor
- rcPropertyParseEnum
- rcPropertyParseFlags
- rcPropertyParseRequisition
- renderActivity
- renderArrow
- renderBackground
- renderBackgroundGetClip
- renderCheck
- renderExpander
- renderFocus
- renderFrame
- renderHandle
- renderIcon
- renderInsertionCursor
- renderLayout
- renderLine
- renderOption
- renderSlider
- rgbToHsv
- setDebugFlags
- showUriOnWindow
- targetsIncludeImage
- targetsIncludeText
- targetsIncludeUri
- testListAllTypes
- testRegisterAllTypes
- testWidgetWaitForDraw
- treeGetRowDragData
- treeSetRowDragData
Synopsis
- accelGroupsActivate :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> [ModifierType] -> m Bool
- accelGroupsFromObject :: (HasCallStack, MonadIO m, IsObject a) => a -> m [AccelGroup]
- acceleratorGetDefaultModMask :: (HasCallStack, MonadIO m) => m [ModifierType]
- acceleratorGetLabel :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text
- acceleratorGetLabelWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text
- acceleratorName :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Text
- acceleratorNameWithKeycode :: (HasCallStack, MonadIO m, IsDisplay a) => Maybe a -> Word32 -> Word32 -> [ModifierType] -> m Text
- acceleratorParse :: (HasCallStack, MonadIO m) => Text -> m (Word32, [ModifierType])
- acceleratorParseWithKeycode :: (HasCallStack, MonadIO m) => Text -> m (Word32, [Word32], [ModifierType])
- acceleratorSetDefaultModMask :: (HasCallStack, MonadIO m) => [ModifierType] -> m ()
- acceleratorValid :: (HasCallStack, MonadIO m) => Word32 -> [ModifierType] -> m Bool
- bindingsActivate :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> [ModifierType] -> m Bool
- bindingsActivateEvent :: (HasCallStack, MonadIO m, IsObject a) => a -> EventKey -> m Bool
- checkVersion :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> Word32 -> m (Maybe Text)
- contentFormatsAddImageTargets :: (HasCallStack, MonadIO m) => ContentFormats -> Bool -> m ContentFormats
- contentFormatsAddTextTargets :: (HasCallStack, MonadIO m) => ContentFormats -> m ContentFormats
- contentFormatsAddUriTargets :: (HasCallStack, MonadIO m) => ContentFormats -> m ContentFormats
- deviceGrabAdd :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> Bool -> m ()
- deviceGrabRemove :: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) => a -> b -> m ()
- disableSetlocale :: (HasCallStack, MonadIO m) => m ()
- distributeNaturalAllocation :: (HasCallStack, MonadIO m) => Int32 -> Word32 -> RequestedSize -> m Int32
- dragCancel :: (HasCallStack, MonadIO m, IsDrag a) => a -> m ()
- dragGetSourceWidget :: (HasCallStack, MonadIO m, IsDrag a) => a -> m (Maybe Widget)
- dragSetIconDefault :: (HasCallStack, MonadIO m, IsDrag a) => a -> m ()
- dragSetIconGicon :: (HasCallStack, MonadIO m, IsDrag a, IsIcon b) => a -> b -> Int32 -> Int32 -> m ()
- dragSetIconName :: (HasCallStack, MonadIO m, IsDrag a) => a -> Text -> Int32 -> Int32 -> m ()
- dragSetIconPaintable :: (HasCallStack, MonadIO m, IsDrag a, IsPaintable b) => a -> b -> Int32 -> Int32 -> m ()
- dragSetIconWidget :: (HasCallStack, MonadIO m, IsDrag a, IsWidget b) => a -> b -> Int32 -> Int32 -> m ()
- eventsPending :: (HasCallStack, MonadIO m) => m Bool
- getBinaryAge :: (HasCallStack, MonadIO m) => m Word32
- getCurrentEvent :: (HasCallStack, MonadIO m) => m (Maybe Event)
- getCurrentEventDevice :: (HasCallStack, MonadIO m) => m (Maybe Device)
- getCurrentEventState :: (HasCallStack, MonadIO m) => m (Bool, [ModifierType])
- getCurrentEventTime :: (HasCallStack, MonadIO m) => m Word32
- getDebugFlags :: (HasCallStack, MonadIO m) => m Word32
- getDefaultLanguage :: (HasCallStack, MonadIO m) => m Language
- getEventTarget :: (HasCallStack, MonadIO m, IsEvent a) => a -> m (Maybe Widget)
- getEventTargetWithType :: (HasCallStack, MonadIO m, IsEvent a) => a -> GType -> m (Maybe Widget)
- getEventWidget :: (HasCallStack, MonadIO m, IsEvent a) => a -> m (Maybe Widget)
- getInterfaceAge :: (HasCallStack, MonadIO m) => m Word32
- getLocaleDirection :: (HasCallStack, MonadIO m) => m TextDirection
- getMainThread :: (HasCallStack, MonadIO m) => m Thread
- getMajorVersion :: (HasCallStack, MonadIO m) => m Word32
- getMicroVersion :: (HasCallStack, MonadIO m) => m Word32
- getMinorVersion :: (HasCallStack, MonadIO m) => m Word32
- grabGetCurrent :: (HasCallStack, MonadIO m) => m (Maybe Widget)
- hsvToRgb :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)
- imModulesInit :: (HasCallStack, MonadIO m) => m ()
- init :: (HasCallStack, MonadIO m) => m ()
- initCheck :: (HasCallStack, MonadIO m) => m Bool
- isInitialized :: (HasCallStack, MonadIO m) => m Bool
- main :: (HasCallStack, MonadIO m) => m ()
- mainDoEvent :: (HasCallStack, MonadIO m, IsEvent a) => a -> m ()
- mainIteration :: (HasCallStack, MonadIO m) => m Bool
- mainIterationDo :: (HasCallStack, MonadIO m) => Bool -> m Bool
- mainLevel :: (HasCallStack, MonadIO m) => m Word32
- mainQuit :: (HasCallStack, MonadIO m) => m ()
- printRunPageSetupDialog :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> m PageSetup
- printRunPageSetupDialogAsync :: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) => Maybe a -> Maybe b -> c -> PageSetupDoneFunc -> m ()
- propagateEvent :: (HasCallStack, MonadIO m, IsWidget a, IsEvent b) => a -> b -> m ()
- rcPropertyParseBorder :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool
- rcPropertyParseColor :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool
- rcPropertyParseEnum :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool
- rcPropertyParseFlags :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool
- rcPropertyParseRequisition :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool
- renderActivity :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderArrow :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderBackground :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderBackgroundGetClip :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Double -> Double -> Double -> Double -> m Rectangle
- renderCheck :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderExpander :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderFocus :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderFrame :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderHandle :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderIcon :: (HasCallStack, MonadIO m, IsStyleContext a, IsTexture b) => a -> Context -> b -> Double -> Double -> m ()
- renderInsertionCursor :: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) => a -> Context -> Double -> Double -> b -> Int32 -> Direction -> m ()
- renderLayout :: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) => a -> Context -> Double -> Double -> b -> m ()
- renderLine :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderOption :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> m ()
- renderSlider :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> Orientation -> m ()
- rgbToHsv :: (HasCallStack, MonadIO m) => Double -> Double -> Double -> m (Double, Double, Double)
- setDebugFlags :: (HasCallStack, MonadIO m) => Word32 -> m ()
- showUriOnWindow :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> Text -> Word32 -> m ()
- targetsIncludeImage :: (HasCallStack, MonadIO m) => [Text] -> Bool -> m Bool
- targetsIncludeText :: (HasCallStack, MonadIO m) => [Text] -> m Bool
- targetsIncludeUri :: (HasCallStack, MonadIO m) => [Text] -> m Bool
- testListAllTypes :: (HasCallStack, MonadIO m) => m ([GType], Word32)
- testRegisterAllTypes :: (HasCallStack, MonadIO m) => m ()
- testWidgetWaitForDraw :: (HasCallStack, MonadIO m, IsWidget a) => a -> m ()
- treeGetRowDragData :: (HasCallStack, MonadIO m) => SelectionData -> m (Bool, Maybe TreeModel, Maybe TreePath)
- treeSetRowDragData :: (HasCallStack, MonadIO m, IsTreeModel a) => SelectionData -> a -> TreePath -> m Bool
Methods
accelGroupsActivate
:: (HasCallStack, MonadIO m, IsObject a) | |
=> a |
|
-> Word32 |
|
-> [ModifierType] |
|
-> m Bool | Returns: |
Finds the first accelerator in any AccelGroup
attached
to object
that matches accelKey
and accelMods
, and
activates that accelerator.
accelGroupsFromObject
accelGroupsFromObject Source #
:: (HasCallStack, MonadIO m, IsObject a) | |
=> a | |
-> m [AccelGroup] | Returns: a list of
all accel groups which are attached to |
Gets a list of all accel groups which are attached to object
.
acceleratorGetDefaultModMask
acceleratorGetDefaultModMask Source #
:: (HasCallStack, MonadIO m) | |
=> m [ModifierType] | Returns: the default accelerator modifier mask |
Gets the modifier mask.
The modifier mask determines which modifiers are considered significant
for keyboard accelerators. See acceleratorSetDefaultModMask
.
acceleratorGetLabel
:: (HasCallStack, MonadIO m) | |
=> Word32 |
|
-> [ModifierType] |
|
-> m Text | Returns: a newly-allocated string representing the accelerator. |
Converts an accelerator keyval and modifier mask into a string which can be used to represent the accelerator to the user.
acceleratorGetLabelWithKeycode
acceleratorGetLabelWithKeycode Source #
:: (HasCallStack, MonadIO m, IsDisplay a) | |
=> Maybe a | |
-> Word32 |
|
-> Word32 |
|
-> [ModifierType] |
|
-> m Text | Returns: a newly-allocated string representing the accelerator. |
Converts an accelerator keyval and modifier mask
into a (possibly translated) string that can be displayed to
a user, similarly to acceleratorGetLabel
, but handling
keycodes.
This is only useful for system-level components, applications
should use acceleratorParse
instead.
acceleratorName
:: (HasCallStack, MonadIO m) | |
=> Word32 |
|
-> [ModifierType] |
|
-> m Text | Returns: a newly-allocated accelerator name |
Converts an accelerator keyval and modifier mask into a string
parseable by acceleratorParse
. For example, if you pass in
KEY_q
and GDK_CONTROL_MASK
, this function returns “<Control>q”.
If you need to display accelerators in the user interface,
see acceleratorGetLabel
.
acceleratorNameWithKeycode
acceleratorNameWithKeycode Source #
:: (HasCallStack, MonadIO m, IsDisplay a) | |
=> Maybe a | |
-> Word32 |
|
-> Word32 |
|
-> [ModifierType] |
|
-> m Text | Returns: a newly allocated accelerator name. |
Converts an accelerator keyval and modifier mask
into a string parseable by acceleratorParseWithKeycode
,
similarly to acceleratorName
but handling keycodes.
This is only useful for system-level components, applications
should use acceleratorParse
instead.
acceleratorParse
:: (HasCallStack, MonadIO m) | |
=> Text |
|
-> m (Word32, [ModifierType]) |
Parses a string representing an accelerator. The format looks like “<Control>a” or “<Shift><Alt>F1” or “<Release>z” (the last one is for key release).
The parser is fairly liberal and allows lower or upper case, and also
abbreviations such as “<Ctl>” and “<Ctrl>”. Key names are parsed using
keyvalFromName
. For character keys the name is not the symbol,
but the lowercase name, e.g. one would use “<Ctrl>minus” instead of
“<Ctrl>-”.
If the parse fails, acceleratorKey
and acceleratorMods
will
be set to 0 (zero).
acceleratorParseWithKeycode
acceleratorParseWithKeycode Source #
:: (HasCallStack, MonadIO m) | |
=> Text |
|
-> m (Word32, [Word32], [ModifierType]) |
Parses a string representing an accelerator, similarly to
acceleratorParse
but handles keycodes as well. This is only
useful for system-level components, applications should use
acceleratorParse
instead.
If acceleratorCodes
is given and the result stored in it is non-Nothing
,
the result must be freed with free
.
If a keycode is present in the accelerator and no acceleratorCodes
is given, the parse will fail.
If the parse fails, acceleratorKey
, acceleratorMods
and
acceleratorCodes
will be set to 0 (zero).
acceleratorSetDefaultModMask
acceleratorSetDefaultModMask Source #
:: (HasCallStack, MonadIO m) | |
=> [ModifierType] |
|
-> m () |
Sets the modifiers that will be considered significant for keyboard
accelerators. The default mod mask depends on the GDK backend in use,
but will typically include GDK_CONTROL_MASK
| GDK_SHIFT_MASK
|
GDK_MOD1_MASK
| GDK_SUPER_MASK
| GDK_HYPER_MASK
| GDK_META_MASK
.
In other words, Control, Shift, Alt, Super, Hyper and Meta. Other
modifiers will by default be ignored by AccelGroup
.
You must include at least the three modifiers Control, Shift and Alt in any value you pass to this function.
The default mod mask should be changed on application startup, before using any accelerator groups.
acceleratorValid
:: (HasCallStack, MonadIO m) | |
=> Word32 |
|
-> [ModifierType] |
|
-> m Bool | Returns: |
Determines whether a given keyval and modifier mask constitute
a valid keyboard accelerator. For example, the KEY_a
keyval
plus GDK_CONTROL_MASK
is valid - this is a “Ctrl+a” accelerator.
But, you can't, for instance, use the KEY_Control_L
keyval
as an accelerator.
bindingsActivate
:: (HasCallStack, MonadIO m, IsObject a) | |
=> a |
|
-> Word32 |
|
-> [ModifierType] |
|
-> m Bool | Returns: |
Find a key binding matching keyval
and modifiers
and activate the
binding on object
.
bindingsActivateEvent
bindingsActivateEvent Source #
:: (HasCallStack, MonadIO m, IsObject a) | |
=> a |
|
-> EventKey |
|
-> m Bool | Returns: |
Looks up key bindings for object
to find one matching
event
, and if one was found, activate it.
checkVersion
:: (HasCallStack, MonadIO m) | |
=> Word32 |
|
-> Word32 |
|
-> Word32 |
|
-> m (Maybe Text) | Returns: |
Checks that the GTK library in use is compatible with the
given version. Generally you would pass in the constants
MAJOR_VERSION
, MINOR_VERSION
, MICRO_VERSION
as the three arguments to this function; that produces
a check that the library in use is compatible with
the version of GTK the application or module was compiled
against.
Compatibility is defined by two things: first the version
of the running library is newer than the version
requiredMajor
.required_minor.requiredMicro
. Second
the running library must be binary compatible with the
version requiredMajor
.required_minor.requiredMicro
(same major version.)
This function is primarily for GTK modules; the module
can call this function to check that it wasn’t loaded
into an incompatible version of GTK. However, such a
check isn’t completely reliable, since the module may be
linked against an old version of GTK and calling the
old version of checkVersion
, but still get loaded
into an application using a newer version of GTK.
contentFormatsAddImageTargets
contentFormatsAddImageTargets Source #
:: (HasCallStack, MonadIO m) | |
=> ContentFormats |
|
-> Bool |
|
-> m ContentFormats |
Appends the image targets supported by SelectionData
to
the target list. All targets are added with the same info
.
contentFormatsAddTextTargets
contentFormatsAddTextTargets Source #
:: (HasCallStack, MonadIO m) | |
=> ContentFormats |
|
-> m ContentFormats |
Appends the text targets supported by SelectionData
to
the target list. All targets are added with the same info
.
contentFormatsAddUriTargets
contentFormatsAddUriTargets Source #
:: (HasCallStack, MonadIO m) | |
=> ContentFormats |
|
-> m ContentFormats |
Appends the URI targets supported by SelectionData
to
the target list. All targets are added with the same info
.
deviceGrabAdd
:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) | |
=> a |
|
-> b |
|
-> Bool |
|
-> m () |
Adds a GTK grab on device
, so all the events on device
and its
associated pointer or keyboard (if any) are delivered to widget
.
If the blockOthers
parameter is True
, any other devices will be
unable to interact with widget
during the grab.
deviceGrabRemove
:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b) | |
=> a |
|
-> b |
|
-> m () |
Removes a device grab from the given widget.
You have to pair calls to deviceGrabAdd
and
deviceGrabRemove
.
disableSetlocale
disableSetlocale :: (HasCallStack, MonadIO m) => m () Source #
Prevents init
, initCheck
and
gtk_parse_args()
from automatically
calling setlocale (LC_ALL, "")
. You would
want to use this function if you wanted to set the locale for
your program to something other than the user’s locale, or if
you wanted to set different values for different locale categories.
Most programs should not need to call this function.
distributeNaturalAllocation
distributeNaturalAllocation Source #
:: (HasCallStack, MonadIO m) | |
=> Int32 |
|
-> Word32 |
|
-> RequestedSize |
|
-> m Int32 | Returns: The remainder of |
Distributes extraSpace
to child sizes
by bringing smaller
children up to natural size first.
The remaining space will be added to the minimumSize
member of the
GtkRequestedSize struct. If all sizes reach their natural size then
the remaining space is returned.
dragCancel
:: (HasCallStack, MonadIO m, IsDrag a) | |
=> a |
|
-> m () |
Cancels an ongoing drag operation on the source side.
If you want to be able to cancel a drag operation in this way,
you need to keep a pointer to the drag context, either from an
explicit call to widgetDragBegin
, or by connecting to
dragBegin.
If context
does not refer to an ongoing drag operation, this
function does nothing.
If a drag is cancelled in this way, the result
argument of
dragFailed is set to gTKDRAGRESULTERROR
.
dragGetSourceWidget
:: (HasCallStack, MonadIO m, IsDrag a) | |
=> a |
|
-> m (Maybe Widget) | Returns: if the drag is occurring
within a single application, a pointer to the source widget.
Otherwise, |
Determines the source widget for a drag.
dragSetIconDefault
:: (HasCallStack, MonadIO m, IsDrag a) | |
=> a |
|
-> m () |
Sets the icon for a particular drag to the default icon.
dragSetIconGicon
:: (HasCallStack, MonadIO m, IsDrag a, IsIcon b) | |
=> a |
|
-> b |
|
-> Int32 |
|
-> Int32 |
|
-> m () |
Sets the icon for a given drag from the given icon
.
See the documentation for dragSetIconName
for more details about using icons in drag and drop.
dragSetIconName
:: (HasCallStack, MonadIO m, IsDrag a) | |
=> a |
|
-> Text |
|
-> Int32 |
|
-> Int32 |
|
-> m () |
Sets the icon for a given drag from a named themed icon. See
the docs for IconTheme
for more details. Note that the
size of the icon depends on the icon theme (the icon is
loaded at the symbolic size GTK_ICON_SIZE_DND
), thus
hotX
and hotY
have to be used with care.
dragSetIconPaintable
:: (HasCallStack, MonadIO m, IsDrag a, IsPaintable b) | |
=> a |
|
-> b |
|
-> Int32 |
|
-> Int32 |
|
-> m () |
Sets paintable
as the icon for a given drag. GTK+ retains
references for the arguments, and will release them when
they are no longer needed.
To position the paintable
relative to the mouse, its top
left will be positioned hotX
, hotY
pixels from the
mouse cursor.
dragSetIconWidget
:: (HasCallStack, MonadIO m, IsDrag a, IsWidget b) | |
=> a |
|
-> b |
|
-> Int32 |
|
-> Int32 |
|
-> m () |
Changes the icon for drag operation to a given widget. GTK+ will not destroy the widget, so if you don’t want it to persist, you should connect to the “drag-end” signal and destroy it yourself.
eventsPending
:: (HasCallStack, MonadIO m) | |
=> m Bool |
Checks if any events are pending.
This can be used to update the UI and invoke timeouts etc. while doing some time intensive computation.
Updating the UI during a long computation
C code
// computation going on... while (gtk_events_pending ()) gtk_main_iteration (); // ...computation continued
getBinaryAge
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the binary age of the GTK library |
Returns the binary age as passed to libtool
when building the GTK library the process is running against.
If libtool
means nothing to you, don't
worry about it.
getCurrentEvent
:: (HasCallStack, MonadIO m) | |
=> m (Maybe Event) | Returns: a reference of the current event, or
|
Obtains a reference of the event currently being processed by GTK.
For example, if you are handling a clicked signal,
the current event will be the EventButton
that triggered
the clicked signal.
getCurrentEventDevice
getCurrentEventDevice Source #
If there is a current event and it has a device, return that
device, otherwise return Nothing
.
getCurrentEventState
:: (HasCallStack, MonadIO m) | |
=> m (Bool, [ModifierType]) | Returns: |
getCurrentEventTime
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the timestamp from the current event,
or |
If there is a current event and it has a timestamp,
return that timestamp, otherwise return CURRENT_TIME
.
getDebugFlags
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the GTK debug flags. |
Returns the GTK debug flags.
This function is intended for GTK modules that want to adjust their debug output based on GTK debug flags.
getDefaultLanguage
:: (HasCallStack, MonadIO m) | |
=> m Language | Returns: the default language as a |
Returns the Language
for the default language currently in
effect. (Note that this can change over the life of an
application.) The default language is derived from the current
locale. It determines, for example, whether GTK uses the
right-to-left or left-to-right text direction.
This function is equivalent to languageGetDefault
.
See that function for details.
getEventTarget
getEventTargetWithType
getEventWidget
getInterfaceAge
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the interface age of the GTK library |
Returns the interface age as passed to libtool
when building the GTK library the process is running against.
If libtool
means nothing to you, don't
worry about it.
getLocaleDirection
:: (HasCallStack, MonadIO m) | |
=> m TextDirection | Returns: the |
Get the direction of the current locale. This is the expected reading direction for text and UI.
This function depends on the current locale being set with
setlocale()
and will default to setting the TextDirectionLtr
direction otherwise. TextDirectionNone
will never be returned.
GTK sets the default text direction according to the locale
during init
, and you should normally use
widgetGetDirection
or widgetGetDefaultDirection
to obtain the current direcion.
This function is only needed rare cases when the locale is changed after GTK has already been initialized. In this case, you can use it to update the default text direction as follows:
C code
setlocale (LC_ALL, new_locale); direction = gtk_get_locale_direction (); gtk_widget_set_default_direction (direction);
getMainThread
:: (HasCallStack, MonadIO m) | |
=> m Thread | Returns: The |
Get the thread from which GTK was initialized.
getMajorVersion
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the major version number of the GTK library |
Returns the major version number of the GTK library. (e.g. in GTK version 3.1.5 this is 3.)
This function is in the library, so it represents the GTK library
your code is running against. Contrast with the MAJOR_VERSION
macro, which represents the major version of the GTK headers you
have included when compiling your code.
getMicroVersion
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the micro version number of the GTK library |
Returns the micro version number of the GTK library. (e.g. in GTK version 3.1.5 this is 5.)
This function is in the library, so it represents the GTK library
your code is are running against. Contrast with the
MICRO_VERSION
macro, which represents the micro version of the
GTK headers you have included when compiling your code.
getMinorVersion
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the minor version number of the GTK library |
Returns the minor version number of the GTK library. (e.g. in GTK version 3.1.5 this is 1.)
This function is in the library, so it represents the GTK library
your code is are running against. Contrast with the
MINOR_VERSION
macro, which represents the minor version of the
GTK headers you have included when compiling your code.
grabGetCurrent
:: (HasCallStack, MonadIO m) | |
=> m (Maybe Widget) | Returns: The widget which currently
has the grab or |
Queries the current grab of the default window group.
hsvToRgb
:: (HasCallStack, MonadIO m) | |
=> Double |
|
-> Double |
|
-> Double |
|
-> m (Double, Double, Double) |
Converts a color from HSV space to RGB.
Input values must be in the [0.0, 1.0] range; output values will be in the same range.
imModulesInit
imModulesInit :: (HasCallStack, MonadIO m) => m () Source #
No description available in the introspection data.
init
init :: (HasCallStack, MonadIO m) => m () Source #
Call this function before using any other GTK functions in your GUI applications. It will initialize everything needed to operate the toolkit and parses some standard command line options.
If you are using Application
, you don't have to call init
or initCheck
; the Application
::startup
handler
does it for you.
This function will terminate your program if it was unable to
initialize the windowing system for some reason. If you want
your program to fall back to a textual interface you want to
call initCheck
instead.
GTK calls signal (SIGPIPE, SIG_IGN)
during initialization, to ignore SIGPIPE signals, since these are
almost never wanted in graphical applications. If you do need to
handle SIGPIPE for some reason, reset the handler after init
,
but notice that other libraries (e.g. libdbus or gvfs) might do
similar things.
initCheck
:: (HasCallStack, MonadIO m) | |
=> m Bool | Returns: |
This function does the same work as init
with only a single
change: It does not terminate the program if the windowing system
can’t be initialized. Instead it returns False
on failure.
This way the application can fall back to some other means of communication with the user - for example a curses or command line interface.
isInitialized
:: (HasCallStack, MonadIO m) | |
=> m Bool | Returns: the initialization status |
main
main :: (HasCallStack, MonadIO m) => m () Source #
mainDoEvent
:: (HasCallStack, MonadIO m, IsEvent a) | |
=> a |
|
-> m () |
Processes a single GDK event.
This is public only to allow filtering of events between GDK and GTK. You will not usually need to call this function directly.
While you should not call this function directly, you might want to know how exactly events are handled. So here is what this function does with the event:
- Compress enter/leave notify events. If the event passed build an enter/leave pair together with the next event (peeked from GDK), both events are thrown away. This is to avoid a backlog of (de-)highlighting widgets crossed by the pointer.
- Find the widget which got the event. If the widget can’t be determined the event is thrown away unless it belongs to a INCR transaction.
- Then the event is pushed onto a stack so you can query the currently
handled event with
getCurrentEvent
. - The event is sent to a widget. If a grab is active all events for widgets that are not in the contained in the grab widget are sent to the latter with a few exceptions: - Deletion and destruction events are still sent to the event widget for obvious reasons. - Events which directly relate to the visual representation of the event widget. - Leave events are delivered to the event widget if there was an enter event delivered to it before without the paired leave event. - Drag events are not redirected because it is unclear what the semantics of that would be.
- After finishing the delivery the event is popped from the event stack.
mainIteration
:: (HasCallStack, MonadIO m) | |
=> m Bool | Returns: |
Runs a single iteration of the mainloop.
If no events are waiting to be processed GTK will block
until the next event is noticed. If you don’t want to block
look at mainIterationDo
or check if any events are
pending with eventsPending
first.
mainIterationDo
:: (HasCallStack, MonadIO m) | |
=> Bool |
|
-> m Bool | Returns: |
Runs a single iteration of the mainloop.
If no events are available either return or block depending on
the value of blocking
.
mainLevel
:: (HasCallStack, MonadIO m) | |
=> m Word32 | Returns: the nesting level of the current invocation of the main loop |
Asks for the current nesting level of the main loop.
mainQuit
mainQuit :: (HasCallStack, MonadIO m) => m () Source #
Makes the innermost invocation of the main loop return when it regains control.
printRunPageSetupDialog
printRunPageSetupDialog Source #
:: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) | |
=> Maybe a |
|
-> Maybe b |
|
-> c |
|
-> m PageSetup | Returns: a new |
Runs a page setup dialog, letting the user modify the values from
pageSetup
. If the user cancels the dialog, the returned PageSetup
is identical to the passed in pageSetup
, otherwise it contains the
modifications done in the dialog.
Note that this function may use a recursive mainloop to show the page
setup dialog. See printRunPageSetupDialogAsync
if this is
a problem.
printRunPageSetupDialogAsync
printRunPageSetupDialogAsync Source #
:: (HasCallStack, MonadIO m, IsWindow a, IsPageSetup b, IsPrintSettings c) | |
=> Maybe a |
|
-> Maybe b | |
-> c |
|
-> PageSetupDoneFunc |
|
-> m () |
Runs a page setup dialog, letting the user modify the values from pageSetup
.
In contrast to printRunPageSetupDialog
, this function returns after
showing the page setup dialog on platforms that support this, and calls doneCb
from a signal handler for the response signal of the dialog.
propagateEvent
:: (HasCallStack, MonadIO m, IsWidget a, IsEvent b) | |
=> a |
|
-> b |
|
-> m () |
Sends an event to a widget, propagating the event to parent widgets
if the event remains unhandled. This function will emit the event
through all the hierarchy of widget
through all propagation phases.
Events received by GTK from GDK normally begin in mainDoEvent
.
Depending on the type of event, existence of modal dialogs, grabs, etc.,
the event may be propagated; if so, this function is used.
propagateEvent
calls widgetEvent
on each widget it
decides to send the event to. So widgetEvent
is the lowest-level
function; it simply emits the Widget
::event
and possibly an
event-specific signal on a widget. propagateEvent
is a bit
higher-level, and mainDoEvent
is the highest level.
All that said, you most likely don’t want to use any of these
functions; synthesizing events is rarely needed. There are almost
certainly better ways to achieve your goals. For example, use
widgetQueueDraw
instead
of making up expose events.
rcPropertyParseBorder
rcPropertyParseBorder Source #
:: (HasCallStack, MonadIO m) | |
=> GParamSpec |
|
-> String |
|
-> GValue |
|
-> m Bool | Returns: |
A RcPropertyParser
for use with gtk_settings_install_property_parser()
or gtk_widget_class_install_style_property_parser()
which parses
borders in the form
"{ left, right, top, bottom }"
for integers
left, right, top and bottom.
rcPropertyParseColor
rcPropertyParseColor :: (HasCallStack, MonadIO m) => GParamSpec -> String -> GValue -> m Bool Source #
No description available in the introspection data.
rcPropertyParseEnum
:: (HasCallStack, MonadIO m) | |
=> GParamSpec |
|
-> String |
|
-> GValue |
|
-> m Bool | Returns: |
A RcPropertyParser
for use with gtk_settings_install_property_parser()
or gtk_widget_class_install_style_property_parser()
which parses a single
enumeration value.
The enumeration value can be specified by its name, its nickname or its numeric value. For consistency with flags parsing, the value may be surrounded by parentheses.
rcPropertyParseFlags
:: (HasCallStack, MonadIO m) | |
=> GParamSpec |
|
-> String |
|
-> GValue |
|
-> m Bool | Returns: |
A RcPropertyParser
for use with gtk_settings_install_property_parser()
or gtk_widget_class_install_style_property_parser()
which parses flags.
Flags can be specified by their name, their nickname or
numerically. Multiple flags can be specified in the form
"( flag1 | flag2 | ... )"
.
rcPropertyParseRequisition
rcPropertyParseRequisition Source #
:: (HasCallStack, MonadIO m) | |
=> GParamSpec |
|
-> String |
|
-> GValue |
|
-> m Bool | Returns: |
A RcPropertyParser
for use with gtk_settings_install_property_parser()
or gtk_widget_class_install_style_property_parser()
which parses a
requisition in the form
"{ width, height }"
for integers width
and height
.
renderActivity
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders an activity indicator (such as in Spinner
).
The state StateFlagsChecked
determines whether there is
activity going on.
renderArrow
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders an arrow pointing to angle
.
Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
renderBackground
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders the background of an element.
Typical background rendering, showing the effect of
background-image
, border-width
and border-radius
:
renderBackgroundGetClip
renderBackgroundGetClip Source #
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m Rectangle |
Returns the area that will be affected (i.e. drawn to) when
calling renderBackground
for the given context
and
rectangle.
renderCheck
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders a checkmark (as in a CheckButton
).
The StateFlagsChecked
state determines whether the check is
on or off, and StateFlagsInconsistent
determines whether it
should be marked as undefined.
Typical checkmark rendering:
renderExpander
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders an expander (as used in TreeView
and Expander
) in the area
defined by x
, y
, width
, height
. The state StateFlagsChecked
determines whether the expander is collapsed or expanded.
Typical expander rendering:
renderFocus
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders a focus indicator on the rectangle determined by x
, y
, width
, height
.
Typical focus rendering:
renderFrame
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders a frame around the rectangle defined by x
, y
, width
, height
.
Examples of frame rendering, showing the effect of border-image
,
border-color
, border-width
, border-radius
and junctions:
renderHandle
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
renderIcon
:: (HasCallStack, MonadIO m, IsStyleContext a, IsTexture b) | |
=> a |
|
-> Context |
|
-> b |
|
-> Double |
|
-> Double |
|
-> m () |
Renders the icon in texture
at the specified x
and y
coordinates.
This function will render the icon in texture
at exactly its size,
regardless of scaling factors, which may not be appropriate when
drawing on displays with high pixel densities.
renderInsertionCursor
renderInsertionCursor Source #
:: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> b |
|
-> Int32 |
|
-> Direction |
|
-> m () |
Draws a text caret on cr
at the specified index of layout
.
renderLayout
:: (HasCallStack, MonadIO m, IsStyleContext a, IsLayout b) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> b |
|
-> m () |
Renders layout
on the coordinates x
, y
renderLine
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders a line from (x0, y0) to (x1, y1).
renderOption
:: (HasCallStack, MonadIO m, IsStyleContext a) | |
=> a |
|
-> Context |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> Double |
|
-> m () |
Renders an option mark (as in a RadioButton
), the StateFlagsChecked
state will determine whether the option is on or off, and
StateFlagsInconsistent
whether it should be marked as undefined.
Typical option mark rendering:
renderSlider
renderSlider :: (HasCallStack, MonadIO m, IsStyleContext a) => a -> Context -> Double -> Double -> Double -> Double -> Orientation -> m () Source #
No description available in the introspection data.
rgbToHsv
:: (HasCallStack, MonadIO m) | |
=> Double |
|
-> Double |
|
-> Double |
|
-> m (Double, Double, Double) |
Converts a color from RGB space to HSV.
Input values must be in the [0.0, 1.0] range; output values will be in the same range.
setDebugFlags
setDebugFlags :: (HasCallStack, MonadIO m) => Word32 -> m () Source #
Sets the GTK debug flags.
showUriOnWindow
:: (HasCallStack, MonadIO m, IsWindow a) | |
=> Maybe a |
|
-> Text |
|
-> Word32 |
|
-> m () | (Can throw |
This is a convenience function for launching the default application to show the uri. The uri must be of a form understood by GIO (i.e. you need to install gvfs to get support for uri schemes such as http:// or ftp://, as only local files are handled by GIO itself). Typical examples are
file:///home/gnome/pict.jpg
http://www.gnome.org
mailto:me@gnome.org
Ideally the timestamp is taken from the event triggering
the showUriOnWindow
call. If timestamp is not known you can take
CURRENT_TIME
.
This is the recommended call to be used as it passes information necessary for sandbox helpers to parent their dialogs properly.
targetsIncludeImage
:: (HasCallStack, MonadIO m) | |
=> [Text] |
|
-> Bool |
|
-> m Bool | Returns: |
Determines if any of the targets in targets
can be used to
provide a Pixbuf
.
targetsIncludeText
:: (HasCallStack, MonadIO m) | |
=> [Text] |
|
-> m Bool | Returns: |
Determines if any of the targets in targets
can be used to
provide text.
targetsIncludeUri
:: (HasCallStack, MonadIO m) | |
=> [Text] |
|
-> m Bool | Returns: |
Determines if any of the targets in targets
can be used to
provide an uri list.
testListAllTypes
:: (HasCallStack, MonadIO m) | |
=> m ([GType], Word32) | Returns: 0-terminated array of type ids |
Return the type ids that have been registered after
calling testRegisterAllTypes
.
testRegisterAllTypes
testRegisterAllTypes :: (HasCallStack, MonadIO m) => m () Source #
Force registration of all core Gtk+ and Gdk object types.
This allowes to refer to any of those object types via
typeFromName
after calling this function.
testWidgetWaitForDraw
testWidgetWaitForDraw Source #
:: (HasCallStack, MonadIO m, IsWidget a) | |
=> a |
|
-> m () |
Enters the main loop and waits for widget
to be “drawn”. In this
context that means it waits for the frame clock of widget
to have
run a full styling, layout and drawing cycle.
This function is intended to be used for syncing with actions that
depend on widget
relayouting or on interaction with the display
server.
treeGetRowDragData
:: (HasCallStack, MonadIO m) | |
=> SelectionData |
|
-> m (Bool, Maybe TreeModel, Maybe TreePath) | Returns: |
Obtains a treeModel
and path
from selection data of target type
GTK_TREE_MODEL_ROW
. Normally called from a drag_data_received handler.
This function can only be used if selectionData
originates from the same
process that’s calling this function, because a pointer to the tree model
is being passed around. If you aren’t in the same process, then you'll
get memory corruption. In the TreeDragDest
drag_data_received handler,
you can assume that selection data of type GTK_TREE_MODEL_ROW
is
in from the current process. The returned path must be freed with
treePathFree
.
treeSetRowDragData
:: (HasCallStack, MonadIO m, IsTreeModel a) | |
=> SelectionData |
|
-> a |
|
-> TreePath |
|
-> m Bool | Returns: |
Sets selection data of target type GTK_TREE_MODEL_ROW
. Normally used
in a drag_data_get handler.