GI.Gtk.Objects.Widget

GtkWidget is the base class all widgets in GTK+ derive from. It manages the widget lifecycle, states and style.

{geometry-management}

GTK+ uses a height-for-width (and width-for-height) geometry management system. Height-for-width means that a widget can change how much vertical space it needs, depending on the amount of horizontal space that it is given (and similar for width-for-height). The most common example is a label that reflows to fill up the available width, wraps to fewer lines, and therefore needs less height.

Height-for-width geometry management is implemented in GTK+ by way of five virtual methods:

• WidgetClass.get_request_mode()
• WidgetClass.get_preferred_width()
• WidgetClass.get_preferred_height()
• WidgetClass.get_preferred_height_for_width()
• WidgetClass.get_preferred_width_for_height()
• WidgetClass.get_preferred_height_and_baseline_for_width()

There are some important things to keep in mind when implementing height-for-width and when using it in container implementations.

The geometry management system will query a widget hierarchy in only one orientation at a time. When widgets are initially queried for their minimum sizes it is generally done in two initial passes in the SizeRequestMode chosen by the toplevel.

For example, when queried in the normal SizeRequestModeHeightForWidth mode: First, the default minimum and natural width for each widget in the interface will be computed using widgetGetPreferredWidth. Because the preferred widths for each container depend on the preferred widths of their children, this information propagates up the hierarchy, and finally a minimum and natural width is determined for the entire toplevel. Next, the toplevel will use the minimum width to query for the minimum height contextual to that width using widgetGetPreferredHeightForWidth, which will also be a highly recursive operation. The minimum height for the minimum width is normally used to set the minimum size constraint on the toplevel (unless windowSetGeometryHints is explicitly used instead).

After the toplevel window has initially requested its size in both dimensions it can go on to allocate itself a reasonable size (or a size previously specified with windowSetDefaultSize). During the recursive allocation process it’s important to note that request cycles will be recursively executed while container widgets allocate their children. Each container widget, once allocated a size, will go on to first share the space in one orientation among its children and then request each child's height for its target allocated width or its width for allocated height, depending. In this way a Widget will typically be requested its size a number of times before actually being allocated a size. The size a widget is finally allocated can of course differ from the size it has requested. For this reason, Widget caches a small number of results to avoid re-querying for the same sizes in one allocation cycle.

See [GtkContainer’s geometry management section][container-geometry-management] to learn more about how height-for-width allocations are performed by container widgets.

If a widget does move content around to intelligently use up the allocated size then it must support the request in both GtkSizeRequestModes even if the widget in question only trades sizes in a single orientation.

For instance, a Label that does height-for-width word wrapping will not expect to have WidgetClass.get_preferred_height() called because that call is specific to a width-for-height request. In this case the label must return the height required for its own minimum possible width. By following this rule any widget that handles height-for-width or width-for-height requests will always be allocated at least enough space to fit its own content.

Here are some examples of how a SizeRequestModeHeightForWidth widget generally deals with width-for-height requests, for WidgetClass.get_preferred_height() it will do:

C code

static void
foo_widget_get_preferred_height (GtkWidget *widget,
                                 gint *min_height,
                                 gint *nat_height)
{
   if (i_am_in_height_for_width_mode)
     {
       gint min_width, nat_width;

       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           &min_width,
                                                           &nat_width);
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
                                                          (widget,
                                                           min_width,
                                                           min_height,
                                                           nat_height);
     }
   else
     {
        ... some widgets do both. For instance, if a GtkLabel is
        rotated to 90 degrees it will return the minimum and
        natural height for the rotated label here.
     }
}

And in WidgetClass.get_preferred_width_for_height() it will simply return the minimum and natural width:

C code

static void
foo_widget_get_preferred_width_for_height (GtkWidget *widget,
                                           gint for_height,
                                           gint *min_width,
                                           gint *nat_width)
{
   if (i_am_in_height_for_width_mode)
     {
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           min_width,
                                                           nat_width);
     }
   else
     {
        ... again if a widget is sometimes operating in
        width-for-height mode (like a rotated GtkLabel) it can go
        ahead and do its real width for height calculation here.
     }
}

Often a widget needs to get its own request during size request or allocation. For example, when computing height it may need to also compute width. Or when deciding how to use an allocation, the widget may need to know its natural size. In these cases, the widget should be careful to call its virtual methods directly, like this:

C code

GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget,
                                                   &min,
                                                   &natural);

It will not work to use the wrapper functions, such as widgetGetPreferredWidth inside your own size request implementation. These return a request adjusted by SizeGroup and by the WidgetClass.adjust_size_request() virtual method. If a widget used the wrappers inside its virtual method implementations, then the adjustments (such as widget margins) would be applied twice. GTK+ therefore does not allow this and will warn if you try to do it.

Of course if you are getting the size request for another widget, such as a child of a container, you must use the wrapper APIs. Otherwise, you would not properly consider widget margins, SizeGroup, and so forth.

Since 3.10 GTK+ also supports baseline vertical alignment of widgets. This means that widgets are positioned such that the typographical baseline of widgets in the same row are aligned. This happens if a widget supports baselines, has a vertical alignment of AlignBaseline, and is inside a container that supports baselines and has a natural “row” that it aligns to the baseline, or a baseline assigned to it by the grandparent.

Baseline alignment support for a widget is done by the WidgetClass.get_preferred_height_and_baseline_for_width() virtual function. It allows you to report a baseline in combination with the minimum and natural height. If there is no baseline you can return -1 to indicate this. The default implementation of this virtual function calls into the WidgetClass.get_preferred_height() and WidgetClass.get_preferred_height_for_width(), so if baselines are not supported it doesn’t need to be implemented.

If a widget ends up baseline aligned it will be allocated all the space in the parent as if it was AlignFill, but the selected baseline can be found via widgetGetAllocatedBaseline. If this has a value other than -1 you need to align the widget such that the baseline appears at the position.

Style Properties

Widget introduces “style properties” - these are basically object properties that are stored not on the object, but in the style object associated to the widget. Style properties are set in [resource files][gtk3-Resource-Files]. This mechanism is used for configuring such things as the location of the scrollbar arrows through the theme, giving theme authors more control over the look of applications without the need to write a theme engine in C.

Use widgetClassInstallStyleProperty to install style properties for a widget class, widgetClassFindStyleProperty or widgetClassListStyleProperties to get information about existing style properties and widgetStyleGetProperty, gtk_widget_style_get() or gtk_widget_style_get_valist() to obtain the value of a style property.

GtkWidget as GtkBuildable

The GtkWidget implementation of the GtkBuildable interface supports a custom <accelerator> element, which has attributes named ”key”, ”modifiers” and ”signal” and allows to specify accelerators.

An example of a UI definition fragment specifying an accelerator: > >class="GtkButton" > key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/ >/object

In addition to accelerators, GtkWidget also support a custom <accessible> element, which supports actions and relations. Properties on the accessible implementation of an object can be set by accessing the internal child “accessible” of a Widget.

An example of a UI definition fragment specifying an accessible: > >class="GtkButton" id="label1"/ > name="label"I am a Label for a Button/property >/object >class="GtkButton" id="button1" > accessibility > action_name="click" translatable="yes"Click the button./action > target="label1" type="labelled-by"/ > /accessibility > internal-child="accessible" > class="AtkObject" id="a11y-button1" > name="accessible-name"Clickable Button/property > /object > /child >/object

Finally, GtkWidget allows style information such as style classes to be associated with widgets, using the custom <style> element: > >class="GtkButton" id="button1" > style > name="my-special-button-class"/ > name="dark-button"/ > /style >/object

# {composite-templates}

GtkWidget exposes some facilities to automate the procedure of creating composite widgets using Builder interface description language.

To create composite widgets with Builder XML, one must associate the interface description with the widget class at class initialization time using widgetClassSetTemplate.

The interface description semantics expected in composite template descriptions is slightly different from regular Builder XML.

Unlike regular interface descriptions, widgetClassSetTemplate will expect a <template> tag as a direct child of the toplevel <interface> tag. The <template> tag must specify the “class” attribute which must be the type name of the widget. Optionally, the “parent” attribute may be specified to specify the direct parent type of the widget type, this is ignored by the GtkBuilder but required for Glade to introspect what kind of properties and internal children exist for a given type when the actual type does not exist.

The XML which is contained inside the <template> tag behaves as if it were added to the <object> tag defining widget itself. You may set properties on widget by inserting <property> tags into the <template> tag, and also add <child> tags to add children and extend widget in the normal way you would with <object> tags.

Additionally, <object> tags can also be added before and after the initial <template> tag in the normal way, allowing one to define auxiliary objects which might be referenced by other widgets declared as children of the <template> tag.

An example of a GtkBuilder Template Definition: > >interface > class="FooWidget" parent="GtkBox" > name="orientation"GTK_ORIENTATION_HORIZONTAL/property > name="spacing"4/property > child > class="GtkButton" id="hello_button" > name="label"Hello World/property > name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/ > /object > /child > child > class="GtkButton" id="goodbye_button" > name="label"Goodbye World/property > /object > /child > /template >/interface

Typically, you'll place the template fragment into a file that is bundled with your project, using Resource. In order to load the template, you need to call widgetClassSetTemplateFromResource from the class initialization of your Widget type:

C code

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...

  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
}

You will also need to call widgetInitTemplate from the instance initialization function:

C code

static void
foo_widget_init (FooWidget *self)
{
  // ...
  gtk_widget_init_template (GTK_WIDGET (self));
}

You can access widgets defined in the template using the widgetGetTemplateChild function, but you will typically declare a pointer in the instance private data structure of your type using the same name as the widget in the template definition, and call gtk_widget_class_bind_template_child_private() with that name, e.g.

C code

typedef struct {
  GtkWidget *hello_button;
  GtkWidget *goodbye_button;
} FooWidgetPrivate;

G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...
  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
                                                FooWidget, hello_button);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
                                                FooWidget, goodbye_button);
}

You can also use gtk_widget_class_bind_template_callback() to connect a signal callback defined in the template with a function visible in the scope of the class, e.g.

C code

// the signal handler has the instance and user data swapped
// because of the swapped="yes" attribute in the template XML
static void
hello_button_clicked (FooWidget *self,
                      GtkButton *button)
{
  g_print ("Hello, world!\n");
}

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...
  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
  gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
}

Exported types

newtype Widget

Constructors

Widget (ManagedPtr Widget)

Instances

GObject Widget

Methods

gobjectType :: Widget -> IO GType

IsImplementorIface Widget

IsObject Widget

IsWidget Widget

IsBuildable Widget

((~) * info (ResolveWidgetMethod t Widget), MethodInfo * info Widget p) => IsLabel t (Widget -> p)

Methods

fromLabel :: Proxy# Symbol t -> Widget -> p

((~) * info (ResolveWidgetMethod t Widget), MethodInfo * info Widget p) => IsLabelProxy t (Widget -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Widget -> p

HasAttributeList * Widget

type AttributeList Widget

type AttributeList Widget

type SignalList Widget

type SignalList Widget

class GObject o => IsWidget o

Instances

(GObject a, UnknownAncestorError Constraint Widget a) => IsWidget a

IsWidget Window

IsWidget Widget

IsWidget TreeView

IsWidget ToolItemGroup

IsWidget ToolItem

IsWidget ToolButton

IsWidget ToggleToolButton

IsWidget ToggleButton

IsWidget Stack

IsWidget SpinButton

IsWidget ShortcutsWindow

IsWidget Separator

IsWidget ScrolledWindow

IsWidget Scrollbar

IsWidget ScaleButton

IsWidget Scale

IsWidget Range

IsWidget RadioButton

IsWidget Popover

IsWidget Paned

IsWidget Misc

IsWidget MenuShell

IsWidget MenuItem

IsWidget Menu

IsWidget ListBoxRow

IsWidget ListBox

IsWidget Label

IsWidget IconView

IsWidget Frame

IsWidget FlowBoxChild

IsWidget FlowBox

IsWidget Entry

IsWidget Dialog

IsWidget Container

IsWidget ComboBox

IsWidget CheckMenuItem

IsWidget CheckButton

IsWidget Calendar

IsWidget ButtonBox

IsWidget Button

IsWidget Box

IsWidget Bin

IsWidget ToolShell

IsWidget CellEditable

IsWidget AccelLabel

IsWidget ActionBar

IsWidget Alignment

IsWidget ApplicationWindow

IsWidget AspectFrame

IsWidget CellView

IsWidget ColorChooserDialog

IsWidget ColorChooserWidget

IsWidget ColorSelection

IsWidget ColorSelectionDialog

IsWidget ComboBoxText

IsWidget DrawingArea

IsWidget EventBox

IsWidget Expander

IsWidget FileChooserDialog

IsWidget Fixed

IsWidget FontChooserDialog

IsWidget FontChooserWidget

IsWidget FontSelection

IsWidget FontSelectionDialog

IsWidget GLArea

IsWidget HBox

IsWidget HButtonBox

IsWidget HPaned

IsWidget HScale

IsWidget HScrollbar

IsWidget HSeparator

IsWidget HeaderBar

IsWidget Invisible

IsWidget Layout

IsWidget OffscreenWindow

IsWidget Overlay

IsWidget Plug

IsWidget PopoverMenu

IsWidget ProgressBar

IsWidget RecentChooserDialog

IsWidget RecentChooserWidget

IsWidget SearchBar

IsWidget SearchEntry

IsWidget ShortcutLabel

IsWidget ShortcutsGroup

IsWidget ShortcutsSection

IsWidget Socket

IsWidget Spinner

IsWidget StackSidebar

IsWidget StackSwitcher

IsWidget Statusbar

IsWidget VBox

IsWidget VButtonBox

IsWidget VPaned

IsWidget VScale

IsWidget VScrollbar

IsWidget VSeparator

IsWidget AppChooser

IsWidget AppChooserButton

IsWidget AppChooserWidget

IsWidget RecentChooserMenu

IsWidget SeparatorToolItem

IsWidget Actionable

IsWidget ColorButton

IsWidget FontButton

IsWidget ImageMenuItem

IsWidget LinkButton

IsWidget LockButton

IsWidget MenuToolButton

IsWidget RadioMenuItem

IsWidget RadioToolButton

IsWidget SeparatorMenuItem

IsWidget Switch

IsWidget TearoffMenuItem

IsWidget VolumeButton

IsWidget AppChooserDialog

IsWidget PlacesSidebar

IsWidget Table

IsWidget AboutDialog

IsWidget Arrow

IsWidget FileChooserButton

IsWidget FileChooserWidget

IsWidget Grid

IsWidget HSV

IsWidget HandleBox

IsWidget Image

IsWidget InfoBar

IsWidget LevelBar

IsWidget MenuBar

IsWidget MenuButton

IsWidget MessageDialog

IsWidget ModelButton

IsWidget Notebook

IsWidget Revealer

IsWidget ShortcutsShortcut

IsWidget TextView

IsWidget ToolPalette

IsWidget Toolbar

IsWidget Viewport

IsWidget Assistant

toWidget :: IsWidget o => o -> IO Widget

noWidget :: Maybe Widget

Methods

activate

data WidgetActivateMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetActivateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetActivateMethodInfo a -> signature -> s

widgetActivate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s activatable

-> m Bool

Returns: True if the widget was activatable

For widgets that can be “activated” (buttons, menu items, etc.) this function activates them. Activation is what happens when you press Enter on a widget during key navigation. If widget isn't activatable, the function returns False.

addAccelerator

data WidgetAddAcceleratorMethodInfo

Instances

((~) * signature (Text -> b -> Word32 -> [ModifierType] -> [AccelFlags] -> m ()), MonadIO m, IsWidget a, IsAccelGroup b) => MethodInfo * WidgetAddAcceleratorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetAddAcceleratorMethodInfo a -> signature -> s

widgetAddAccelerator

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b)

=> a

widget: widget to install an accelerator on

-> Text

accelSignal: widget signal to emit on accelerator activation

-> b

accelGroup: accel group for this widget, added to its toplevel

-> Word32

accelKey: GDK keyval of the accelerator

-> [ModifierType]

accelMods: modifier key combination of the accelerator

-> [AccelFlags]

accelFlags: flag accelerators, e.g. AccelFlagsVisible

-> m ()

Installs an accelerator for this widget in accelGroup that causes accelSignal to be emitted if the accelerator is activated. The accelGroup needs to be added to the widget’s toplevel via windowAddAccelGroup, and the signal must be of type SignalFlagsAction. Accelerators added through this function are not user changeable during runtime. If you want to support accelerators that can be changed by the user, use accelMapAddEntry and widgetSetAccelPath or menuItemSetAccelPath instead.

addDeviceEvents

data WidgetAddDeviceEventsMethodInfo

Instances

((~) * signature (b -> [EventMask] -> m ()), MonadIO m, IsWidget a, IsDevice b) => MethodInfo * WidgetAddDeviceEventsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetAddDeviceEventsMethodInfo a -> signature -> s

widgetAddDeviceEvents

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: a Widget

-> b

device: a Device

-> [EventMask]

events: an event mask, see EventMask

-> m ()

Adds the device events in the bitfield events to the event mask for widget. See widgetSetDeviceEvents for details.

Since: 3.0

addEvents

data WidgetAddEventsMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetAddEventsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetAddEventsMethodInfo a -> signature -> s

widgetAddEvents

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

events: an event mask, see EventMask

-> m ()

Adds the events in the bitfield events to the event mask for widget. See widgetSetEvents and the [input handling overview][event-masks] for details.

addMnemonicLabel

data WidgetAddMnemonicLabelMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => MethodInfo * WidgetAddMnemonicLabelMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetAddMnemonicLabelMethodInfo a -> signature -> s

widgetAddMnemonicLabel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

label: a Widget that acts as a mnemonic label for widget

-> m ()

Adds a widget to the list of mnemonic labels for this widget. (See widgetListMnemonicLabels). Note the list of mnemonic labels for the widget is cleared when the widget is destroyed, so the caller must make sure to update its internal state at this point as well, by using a connection to the Widget::destroy signal or a weak notifier.

Since: 2.4

addTickCallback

data WidgetAddTickCallbackMethodInfo

Instances

((~) * signature (TickCallback -> m Word32), MonadIO m, IsWidget a) => MethodInfo * WidgetAddTickCallbackMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetAddTickCallbackMethodInfo a -> signature -> s

widgetAddTickCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> TickCallback

callback: function to call for updating animations

-> m Word32

Returns: an id for the connection of this callback. Remove the callback by passing it to widgetRemoveTickCallback

Queues an animation frame update and adds a callback to be called before each frame. Until the tick callback is removed, it will be called frequently (usually at the frame rate of the output device or as quickly as the application can be repainted, whichever is slower). For this reason, is most suitable for handling graphics that change every frame or every few frames. The tick callback does not automatically imply a relayout or repaint. If you want a repaint or relayout, and aren’t changing widget properties that would trigger that (for example, changing the text of a Label), then you will have to call widgetQueueResize or widgetQueueDrawArea yourself.

frameClockGetFrameTime should generally be used for timing continuous animations and frameTimingsGetPredictedPresentationTime if you are trying to display isolated frames at particular times.

This is a more convenient alternative to connecting directly to the FrameClock::update signal of FrameClock, since you don't have to worry about when a FrameClock is assigned to a widget.

Since: 3.8

canActivateAccel

data WidgetCanActivateAccelMethodInfo

Instances

((~) * signature (Word32 -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetCanActivateAccelMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetCanActivateAccelMethodInfo a -> signature -> s

widgetCanActivateAccel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Word32

signalId: the ID of a signal installed on widget

-> m Bool

Returns: True if the accelerator can be activated.

Determines whether an accelerator that activates the signal identified by signalId can currently be activated. This is done by emitting the Widget::can-activate-accel signal on widget; if the signal isn’t overridden by a handler or in a derived widget, then the default check is that the widget must be sensitive, and the widget and all its ancestors mapped.

Since: 2.4

childFocus

data WidgetChildFocusMethodInfo

Instances

((~) * signature (DirectionType -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetChildFocusMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetChildFocusMethodInfo a -> signature -> s

widgetChildFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> DirectionType

direction: direction of focus movement

-> m Bool

Returns: True if focus ended up inside widget

This function is used by custom widget implementations; if you're writing an app, you’d use widgetGrabFocus to move the focus to a particular widget, and containerSetFocusChain to change the focus tab order. So you may want to investigate those functions instead.

widgetChildFocus is called by containers as the user moves around the window using keyboard shortcuts. direction indicates what kind of motion is taking place (up, down, left, right, tab forward, tab backward). widgetChildFocus emits the Widget::focus signal; widgets override the default handler for this signal in order to implement appropriate focus behavior.

The default ::focus handler for a widget should return True if moving in direction left the focus on a focusable location inside that widget, and False if moving in direction moved the focus outside the widget. If returning True, widgets normally call widgetGrabFocus to place the focus accordingly; if returning False, they don’t modify the current focus location.

childNotify

data WidgetChildNotifyMethodInfo

Instances

((~) * signature (Text -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetChildNotifyMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetChildNotifyMethodInfo a -> signature -> s

widgetChildNotify

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

childProperty: the name of a child property installed on the class of widget’s parent

-> m ()

Emits a Widget::child-notify signal for the [child property][child-properties] childProperty on widget.

This is the analogue of objectNotify for child properties.

Also see containerChildNotify.

classPath

data WidgetClassPathMethodInfo

Instances

((~) * signature (m (Word32, Text, Text)), MonadIO m, IsWidget a) => MethodInfo * WidgetClassPathMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetClassPathMethodInfo a -> signature -> s

widgetClassPath

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Word32, Text, Text)

Deprecated: (Since version 3.0)Use widgetGetPath instead

Same as widgetPath, but always uses the name of a widget’s type, never uses a custom name set with widgetSetName.

computeExpand

data WidgetComputeExpandMethodInfo

Instances

((~) * signature (Orientation -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetComputeExpandMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetComputeExpandMethodInfo a -> signature -> s

widgetComputeExpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Orientation

orientation: expand direction

-> m Bool

Returns: whether widget tree rooted here should be expanded

Computes whether a container should give this widget extra space when possible. Containers should check this, rather than looking at widgetGetHexpand or widgetGetVexpand.

This function already checks whether the widget is visible, so visibility does not need to be checked separately. Non-visible widgets are not expanded.

The computed expand value uses either the expand setting explicitly set on the widget itself, or, if none has been explicitly set, the widget may expand if some of its children do.

createPangoContext

data WidgetCreatePangoContextMethodInfo

Instances

((~) * signature (m Context), MonadIO m, IsWidget a) => MethodInfo * WidgetCreatePangoContextMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetCreatePangoContextMethodInfo a -> signature -> s

widgetCreatePangoContext

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Context

Returns: the new Context

Creates a new Context with the appropriate font map, font options, font description, and base direction for drawing text for this widget. See also widgetGetPangoContext.

createPangoLayout

data WidgetCreatePangoLayoutMethodInfo

Instances

((~) * signature (Maybe Text -> m Layout), MonadIO m, IsWidget a) => MethodInfo * WidgetCreatePangoLayoutMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetCreatePangoLayoutMethodInfo a -> signature -> s

widgetCreatePangoLayout

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Text

text: text to set on the layout (can be Nothing)

-> m Layout

Returns: the new Layout

Creates a new Layout with the appropriate font map, font description, and base direction for drawing text for this widget.

If you keep a Layout created in this way around, you need to re-create it when the widget Context is replaced. This can be tracked by using the Widget::screen-changed signal on the widget.

destroy

data WidgetDestroyMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDestroyMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDestroyMethodInfo a -> signature -> s

widgetDestroy

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Destroys a widget.

When a widget is destroyed all references it holds on other objects will be released:

• if the widget is inside a container, it will be removed from its parent
• if the widget is a container, all its children will be destroyed, recursively
• if the widget is a top level, it will be removed from the list of top level widgets that GTK+ maintains internally

It's expected that all references held on the widget will also be released; you should connect to the Widget::destroy signal if you hold a reference to widget and you wish to remove it when this function is called. It is not necessary to do so if you are implementing a Container, as you'll be able to use the ContainerClass.remove() virtual function for that.

It's important to notice that widgetDestroy will only cause the widget to be finalized if no additional references, acquired using objectRef, are held on it. In case additional references are in place, the widget will be in an "inert" state after calling this function; widget will still point to valid memory, allowing you to release the references you hold, but you may not query the widget's own state.

You should typically call this function on top level widgets, and rarely on child widgets.

See also: containerRemove

destroyed

data WidgetDestroyedMethodInfo

Instances

((~) * signature (b -> m Widget), MonadIO m, IsWidget a, IsWidget b) => MethodInfo * WidgetDestroyedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDestroyedMethodInfo a -> signature -> s

widgetDestroyed

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

widgetPointer: address of a variable that contains widget

-> m Widget

This function sets *widgetPointer to Nothing if widgetPointer != Nothing. It’s intended to be used as a callback connected to the “destroy” signal of a widget. You connect widgetDestroyed as a signal handler, and pass the address of your widget variable as user data. Then when the widget is destroyed, the variable will be set to Nothing. Useful for example to avoid multiple copies of the same dialog.

deviceIsShadowed

data WidgetDeviceIsShadowedMethodInfo

Instances

((~) * signature (b -> m Bool), MonadIO m, IsWidget a, IsDevice b) => MethodInfo * WidgetDeviceIsShadowedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDeviceIsShadowedMethodInfo a -> signature -> s

widgetDeviceIsShadowed

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: a Widget

-> b

device: a Device

-> m Bool

Returns: True if there is an ongoing grab on device by another Widget than widget.

Returns True if device has been shadowed by a GTK+ device grab on another widget, so it would stop sending events to widget. This may be used in the Widget::grab-notify signal to check for specific devices. See deviceGrabAdd.

Since: 3.0

dragBegin

data WidgetDragBeginMethodInfo

Instances

((~) * signature (TargetList -> [DragAction] -> Int32 -> Maybe Event -> m DragContext), MonadIO m, IsWidget a) => MethodInfo * WidgetDragBeginMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragBeginMethodInfo a -> signature -> s

widgetDragBegin

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the source widget

-> TargetList

targets: The targets (data formats) in which the source can provide the data

-> [DragAction]

actions: A bitmask of the allowed drag actions for this drag

-> Int32

button: The button the user clicked to start the drag

-> Maybe Event

event: The event that triggered the start of the drag, or Nothing if none can be obtained.

-> m DragContext

Returns: the context for this drag

Deprecated: (Since version 3.10)Use widgetDragBeginWithCoordinates instead

This function is equivalent to widgetDragBeginWithCoordinates, passing -1, -1 as coordinates.

dragBeginWithCoordinates

data WidgetDragBeginWithCoordinatesMethodInfo

Instances

((~) * signature (TargetList -> [DragAction] -> Int32 -> Maybe Event -> Int32 -> Int32 -> m DragContext), MonadIO m, IsWidget a) => MethodInfo * WidgetDragBeginWithCoordinatesMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragBeginWithCoordinatesMethodInfo a -> signature -> s

widgetDragBeginWithCoordinates

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the source widget

-> TargetList

targets: The targets (data formats) in which the source can provide the data

-> [DragAction]

actions: A bitmask of the allowed drag actions for this drag

-> Int32

button: The button the user clicked to start the drag

-> Maybe Event

event: The event that triggered the start of the drag, or Nothing if none can be obtained.

-> Int32

x: The initial x coordinate to start dragging from, in the coordinate space of widget. If -1 is passed, the coordinates are retrieved from event or the current pointer position

-> Int32

y: The initial y coordinate to start dragging from, in the coordinate space of widget. If -1 is passed, the coordinates are retrieved from event or the current pointer position

-> m DragContext

Returns: the context for this drag

Initiates a drag on the source side. The function only needs to be used when the application is starting drags itself, and is not needed when widgetDragSourceSet is used.

The event is used to retrieve the timestamp that will be used internally to grab the pointer. If event is Nothing, then CURRENT_TIME will be used. However, you should try to pass a real event in all cases, since that can be used to get information about the drag.

Generally there are three cases when you want to start a drag by hand by calling this function:

1. During a Widget::button-press-event handler, if you want to start a drag immediately when the user presses the mouse button. Pass the event that you have in your Widget::button-press-event handler.
2. During a Widget::motion-notify-event handler, if you want to start a drag when the mouse moves past a certain threshold distance after a button-press. Pass the event that you have in your Widget::motion-notify-event handler.
3. During a timeout handler, if you want to start a drag after the mouse button is held down for some time. Try to save the last event that you got from the mouse, using eventCopy, and pass it to this function (remember to free the event with eventFree when you are done). If you can really not pass a real event, pass NULL instead.

Since: 3.10

dragCheckThreshold

data WidgetDragCheckThresholdMethodInfo

Instances

((~) * signature (Int32 -> Int32 -> Int32 -> Int32 -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetDragCheckThresholdMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragCheckThresholdMethodInfo a -> signature -> s

widgetDragCheckThreshold

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

startX: X coordinate of start of drag

-> Int32

startY: Y coordinate of start of drag

-> Int32

currentX: current X coordinate

-> Int32

currentY: current Y coordinate

-> m Bool

Returns: True if the drag threshold has been passed.

Checks to see if a mouse drag starting at (startX, startY) and ending at (currentX, currentY) has passed the GTK+ drag threshold, and thus should trigger the beginning of a drag-and-drop operation.

dragDestAddImageTargets

data WidgetDragDestAddImageTargetsMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestAddImageTargetsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestAddImageTargetsMethodInfo a -> signature -> s

widgetDragDestAddImageTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m ()

Add the image targets supported by SelectionData to the target list of the drag destination. The targets are added with info = 0. If you need another value, use targetListAddImageTargets and widgetDragDestSetTargetList.

Since: 2.6

dragDestAddTextTargets

data WidgetDragDestAddTextTargetsMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestAddTextTargetsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestAddTextTargetsMethodInfo a -> signature -> s

widgetDragDestAddTextTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m ()

Add the text targets supported by SelectionData to the target list of the drag destination. The targets are added with info = 0. If you need another value, use targetListAddTextTargets and widgetDragDestSetTargetList.

Since: 2.6

dragDestAddUriTargets

data WidgetDragDestAddUriTargetsMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestAddUriTargetsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestAddUriTargetsMethodInfo a -> signature -> s

widgetDragDestAddUriTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m ()

Add the URI targets supported by SelectionData to the target list of the drag destination. The targets are added with info = 0. If you need another value, use targetListAddUriTargets and widgetDragDestSetTargetList.

Since: 2.6

dragDestFindTarget

data WidgetDragDestFindTargetMethodInfo

Instances

((~) * signature (b -> Maybe TargetList -> m Atom), MonadIO m, IsWidget a, IsDragContext b) => MethodInfo * WidgetDragDestFindTargetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestFindTargetMethodInfo a -> signature -> s

widgetDragDestFindTarget

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b)

=> a

widget: drag destination widget

-> b

context: drag context

-> Maybe TargetList

targetList: list of droppable targets, or Nothing to use gtk_drag_dest_get_target_list (widget).

-> m Atom

Returns: first target that the source offers and the dest can accept, or GDK_NONE

Looks for a match between the supported targets of context and the destTargetList, returning the first matching target, otherwise returning GDK_NONE. destTargetList should usually be the return value from widgetDragDestGetTargetList, but some widgets may have different valid targets for different parts of the widget; in that case, they will have to implement a drag_motion handler that passes the correct target list to this function.

dragDestGetTargetList

data WidgetDragDestGetTargetListMethodInfo

Instances

((~) * signature (m (Maybe TargetList)), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestGetTargetListMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestGetTargetListMethodInfo a -> signature -> s

widgetDragDestGetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe TargetList)

Returns: the TargetList, or Nothing if none

Returns the list of targets this widget can accept from drag-and-drop.

dragDestGetTrackMotion

data WidgetDragDestGetTrackMotionMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestGetTrackMotionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestGetTrackMotionMethodInfo a -> signature -> s

widgetDragDestGetTrackMotion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m Bool

Returns: True if the widget always emits Widget::drag-motion events

Returns whether the widget has been configured to always emit Widget::drag-motion signals.

Since: 2.10

dragDestSet

data WidgetDragDestSetMethodInfo

Instances

((~) * signature ([DestDefaults] -> Maybe [TargetEntry] -> [DragAction] -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestSetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestSetMethodInfo a -> signature -> s

widgetDragDestSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [DestDefaults]

flags: which types of default drag behavior to use

-> Maybe [TargetEntry]

targets: a pointer to an array of GtkTargetEntrys indicating the drop types that this widget will accept, or Nothing. Later you can access the list with widgetDragDestGetTargetList and widgetDragDestFindTarget.

-> [DragAction]

actions: a bitmask of possible actions for a drop onto this widget.

-> m ()

Sets a widget as a potential drop destination, and adds default behaviors.

The default behaviors listed in flags have an effect similar to installing default handlers for the widget’s drag-and-drop signals (Widget::drag-motion, Widget::drag-drop, ...). They all exist for convenience. When passing GTK_DEST_DEFAULT_ALL for instance it is sufficient to connect to the widget’s Widget::drag-data-received signal to get primitive, but consistent drag-and-drop support.

Things become more complicated when you try to preview the dragged data, as described in the documentation for Widget::drag-motion. The default behaviors described by flags make some assumptions, that can conflict with your own signal handlers. For instance GTK_DEST_DEFAULT_DROP causes invokations of dragStatus in the context of Widget::drag-motion, and invokations of dragFinish in Widget::drag-data-received. Especially the later is dramatic, when your own Widget::drag-motion handler calls widgetDragGetData to inspect the dragged data.

There’s no way to set a default action here, you can use the Widget::drag-motion callback for that. Here’s an example which selects the action to use depending on whether the control key is pressed or not:

C code

static void
drag_motion (GtkWidget *widget,
             GdkDragContext *context,
             gint x,
             gint y,
             guint time)
{
  GdkModifierType mask;

  gdk_window_get_pointer (gtk_widget_get_window (widget),
                          NULL, NULL, &mask);
  if (mask & GDK_CONTROL_MASK)
    gdk_drag_status (context, GDK_ACTION_COPY, time);
  else
    gdk_drag_status (context, GDK_ACTION_MOVE, time);
}

dragDestSetProxy

data WidgetDragDestSetProxyMethodInfo

Instances

((~) * signature (b -> DragProtocol -> Bool -> m ()), MonadIO m, IsWidget a, IsWindow b) => MethodInfo * WidgetDragDestSetProxyMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestSetProxyMethodInfo a -> signature -> s

widgetDragDestSetProxy

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWindow b)

=> a

widget: a Widget

-> b

proxyWindow: the window to which to forward drag events

-> DragProtocol

protocol: the drag protocol which the proxyWindow accepts (You can use gdk_drag_get_protocol() to determine this)

-> Bool

useCoordinates: If True, send the same coordinates to the destination, because it is an embedded subwindow.

-> m ()

Deprecated: (Since version 3.22)

Sets this widget as a proxy for drops to another window.

dragDestSetTargetList

data WidgetDragDestSetTargetListMethodInfo

Instances

((~) * signature (Maybe TargetList -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestSetTargetListMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestSetTargetListMethodInfo a -> signature -> s

widgetDragDestSetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> Maybe TargetList

targetList: list of droppable targets, or Nothing for none

-> m ()

Sets the target types that this widget can accept from drag-and-drop. The widget must first be made into a drag destination with widgetDragDestSet.

dragDestSetTrackMotion

data WidgetDragDestSetTrackMotionMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestSetTrackMotionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestSetTrackMotionMethodInfo a -> signature -> s

widgetDragDestSetTrackMotion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> Bool

trackMotion: whether to accept all targets

-> m ()

Tells the widget to emit Widget::drag-motion and Widget::drag-leave events regardless of the targets and the DestDefaultsMotion flag.

This may be used when a widget wants to do generic actions regardless of the targets that the source offers.

Since: 2.10

dragDestUnset

data WidgetDragDestUnsetMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragDestUnsetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragDestUnsetMethodInfo a -> signature -> s

widgetDragDestUnset

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Clears information about a drop destination set with widgetDragDestSet. The widget will no longer receive notification of drags.

dragGetData

data WidgetDragGetDataMethodInfo

Instances

((~) * signature (b -> Atom -> Word32 -> m ()), MonadIO m, IsWidget a, IsDragContext b) => MethodInfo * WidgetDragGetDataMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragGetDataMethodInfo a -> signature -> s

widgetDragGetData

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDragContext b)

=> a

widget: the widget that will receive the Widget::drag-data-received signal

-> b

context: the drag context

-> Atom

target: the target (form of the data) to retrieve

-> Word32

time_: a timestamp for retrieving the data. This will generally be the time received in a Widget::drag-motion or Widget::drag-drop signal

-> m ()

Gets the data associated with a drag. When the data is received or the retrieval fails, GTK+ will emit a Widget::drag-data-received signal. Failure of the retrieval is indicated by the length field of the selectionData signal parameter being negative. However, when widgetDragGetData is called implicitely because the DestDefaultsDrop was set, then the widget will not receive notification of failed drops.

dragHighlight

data WidgetDragHighlightMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragHighlightMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragHighlightMethodInfo a -> signature -> s

widgetDragHighlight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a widget to highlight

-> m ()

Highlights a widget as a currently hovered drop target. To end the highlight, call widgetDragUnhighlight. GTK+ calls this automatically if DestDefaultsHighlight is set.

dragSourceAddImageTargets

data WidgetDragSourceAddImageTargetsMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceAddImageTargetsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceAddImageTargetsMethodInfo a -> signature -> s

widgetDragSourceAddImageTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s is a drag source

-> m ()

Add the writable image targets supported by SelectionData to the target list of the drag source. The targets are added with info = 0. If you need another value, use targetListAddImageTargets and widgetDragSourceSetTargetList.

Since: 2.6

dragSourceAddTextTargets

data WidgetDragSourceAddTextTargetsMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceAddTextTargetsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceAddTextTargetsMethodInfo a -> signature -> s

widgetDragSourceAddTextTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s is a drag source

-> m ()

Add the text targets supported by SelectionData to the target list of the drag source. The targets are added with info = 0. If you need another value, use targetListAddTextTargets and widgetDragSourceSetTargetList.

Since: 2.6

dragSourceAddUriTargets

data WidgetDragSourceAddUriTargetsMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceAddUriTargetsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceAddUriTargetsMethodInfo a -> signature -> s

widgetDragSourceAddUriTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s is a drag source

-> m ()

Add the URI targets supported by SelectionData to the target list of the drag source. The targets are added with info = 0. If you need another value, use targetListAddUriTargets and widgetDragSourceSetTargetList.

Since: 2.6

dragSourceGetTargetList

data WidgetDragSourceGetTargetListMethodInfo

Instances

((~) * signature (m (Maybe TargetList)), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceGetTargetListMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceGetTargetListMethodInfo a -> signature -> s

widgetDragSourceGetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe TargetList)

Returns: the TargetList, or Nothing if none

Gets the list of targets this widget can provide for drag-and-drop.

Since: 2.4

dragSourceSet

data WidgetDragSourceSetMethodInfo

Instances

((~) * signature ([ModifierType] -> Maybe [TargetEntry] -> [DragAction] -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceSetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceSetMethodInfo a -> signature -> s

widgetDragSourceSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [ModifierType]

startButtonMask: the bitmask of buttons that can start the drag

-> Maybe [TargetEntry]

targets: the table of targets that the drag will support, may be Nothing

-> [DragAction]

actions: the bitmask of possible actions for a drag from this widget

-> m ()

Sets up a widget so that GTK+ will start a drag operation when the user clicks and drags on the widget. The widget must have a window.

dragSourceSetIconGicon

data WidgetDragSourceSetIconGiconMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsIcon b) => MethodInfo * WidgetDragSourceSetIconGiconMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceSetIconGiconMethodInfo a -> signature -> s

widgetDragSourceSetIconGicon

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsIcon b)

=> a

widget: a Widget

-> b

icon: A Icon

-> m ()

Sets the icon that will be used for drags from a particular source to icon. See the docs for IconTheme for more details.

Since: 3.2

dragSourceSetIconName

data WidgetDragSourceSetIconNameMethodInfo

Instances

((~) * signature (Text -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceSetIconNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceSetIconNameMethodInfo a -> signature -> s

widgetDragSourceSetIconName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

iconName: name of icon to use

-> m ()

Sets the icon that will be used for drags from a particular source to a themed icon. See the docs for IconTheme for more details.

Since: 2.8

dragSourceSetIconPixbuf

data WidgetDragSourceSetIconPixbufMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsPixbuf b) => MethodInfo * WidgetDragSourceSetIconPixbufMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceSetIconPixbufMethodInfo a -> signature -> s

widgetDragSourceSetIconPixbuf

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsPixbuf b)

=> a

widget: a Widget

-> b

pixbuf: the Pixbuf for the drag icon

-> m ()

Sets the icon that will be used for drags from a particular widget from a Pixbuf. GTK+ retains a reference for pixbuf and will release it when it is no longer needed.

dragSourceSetIconStock

data WidgetDragSourceSetIconStockMethodInfo

Instances

((~) * signature (Text -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceSetIconStockMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceSetIconStockMethodInfo a -> signature -> s

widgetDragSourceSetIconStock

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

stockId: the ID of the stock icon to use

-> m ()

Deprecated: (Since version 3.10)Use widgetDragSourceSetIconName instead.

Sets the icon that will be used for drags from a particular source to a stock icon.

dragSourceSetTargetList

data WidgetDragSourceSetTargetListMethodInfo

Instances

((~) * signature (Maybe TargetList -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceSetTargetListMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceSetTargetListMethodInfo a -> signature -> s

widgetDragSourceSetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag source

-> Maybe TargetList

targetList: list of draggable targets, or Nothing for none

-> m ()

Changes the target types that this widget offers for drag-and-drop. The widget must first be made into a drag source with widgetDragSourceSet.

Since: 2.4

dragSourceUnset

data WidgetDragSourceUnsetMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragSourceUnsetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragSourceUnsetMethodInfo a -> signature -> s

widgetDragSourceUnset

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Undoes the effects of widgetDragSourceSet.

dragUnhighlight

data WidgetDragUnhighlightMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDragUnhighlightMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDragUnhighlightMethodInfo a -> signature -> s

widgetDragUnhighlight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a widget to remove the highlight from

-> m ()

Removes a highlight set by widgetDragHighlight from a widget.

draw

data WidgetDrawMethodInfo

Instances

((~) * signature (Context -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetDrawMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetDrawMethodInfo a -> signature -> s

widgetDraw

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to draw. It must be drawable (see widgetIsDrawable) and a size must have been allocated.

-> Context

cr: a cairo context to draw to

-> m ()

Draws widget to cr. The top left corner of the widget will be drawn to the currently set origin point of cr.

You should pass a cairo context as cr argument that is in an original state. Otherwise the resulting drawing is undefined. For example changing the operator using cairo_set_operator() or the line width using cairo_set_line_width() might have unwanted side effects. You may however change the context’s transform matrix - like with cairo_scale(), cairo_translate() or cairo_set_matrix() and clip region with cairo_clip() prior to calling this function. Also, it is fine to modify the context with cairo_save() and cairo_push_group() prior to calling this function.

Note that special-purpose widgets may contain special code for rendering to the screen and might appear differently on screen and when rendered using widgetDraw.

Since: 3.0

ensureStyle

data WidgetEnsureStyleMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetEnsureStyleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetEnsureStyleMethodInfo a -> signature -> s

widgetEnsureStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Deprecated: (Since version 3.0)Use StyleContext instead

Ensures that widget has a style (widget->style).

Not a very useful function; most of the time, if you want the style, the widget is realized, and realized widgets are guaranteed to have a style already.

errorBell

data WidgetErrorBellMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetErrorBellMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetErrorBellMethodInfo a -> signature -> s

widgetErrorBell

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Notifies the user about an input-related error on this widget. If the Settings:gtk-error-bell setting is True, it calls windowBeep, otherwise it does nothing.

Note that the effect of windowBeep can be configured in many ways, depending on the windowing backend and the desktop environment or window manager that is used.

Since: 2.12

event

data WidgetEventMethodInfo

Instances

((~) * signature (Event -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetEventMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetEventMethodInfo a -> signature -> s

widgetEvent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Event

event: a Event

-> m Bool

Returns: return from the event signal emission (True if the event was handled)

Rarely-used function. This function is used to emit the event signals on a widget (those signals should never be emitted without using this function to do so). If you want to synthesize an event though, don’t use this function; instead, use mainDoEvent so the event will behave as if it were in the event queue. Don’t synthesize expose events; instead, use windowInvalidateRect to invalidate a region of the window.

freezeChildNotify

data WidgetFreezeChildNotifyMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetFreezeChildNotifyMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetFreezeChildNotifyMethodInfo a -> signature -> s

widgetFreezeChildNotify

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Stops emission of Widget::child-notify signals on widget. The signals are queued until widgetThawChildNotify is called on widget.

This is the analogue of objectFreezeNotify for child properties.

getAccessible

data WidgetGetAccessibleMethodInfo

Instances

((~) * signature (m Object), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAccessibleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAccessibleMethodInfo a -> signature -> s

widgetGetAccessible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Object

Returns: the Object associated with widget

Returns the accessible object that describes the widget to an assistive technology.

If accessibility support is not available, this Object instance may be a no-op. Likewise, if no class-specific Object implementation is available for the widget instance in question, it will inherit an Object implementation from the first ancestor class for which such an implementation is defined.

The documentation of the ATK library contains more information about accessible objects and their uses.

getActionGroup

data WidgetGetActionGroupMethodInfo

Instances

((~) * signature (Text -> m (Maybe ActionGroup)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetActionGroupMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetActionGroupMethodInfo a -> signature -> s

widgetGetActionGroup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget

-> Text

prefix: The “prefix” of the action group.

-> m (Maybe ActionGroup)

Returns: A ActionGroup or Nothing.

Retrieves the ActionGroup that was registered using prefix. The resulting ActionGroup may have been registered to widget or any Widget in its ancestry.

If no action group was found matching prefix, then Nothing is returned.

Since: 3.16

getAllocatedBaseline

data WidgetGetAllocatedBaselineMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAllocatedBaselineMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAllocatedBaselineMethodInfo a -> signature -> s

widgetGetAllocatedBaseline

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> m Int32

Returns: the baseline of the widget, or -1 if none

Returns the baseline that has currently been allocated to widget. This function is intended to be used when implementing handlers for the Widget::draw function, and when allocating child widgets in Widget::size_allocate.

Since: 3.10

getAllocatedHeight

data WidgetGetAllocatedHeightMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAllocatedHeightMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAllocatedHeightMethodInfo a -> signature -> s

widgetGetAllocatedHeight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> m Int32

Returns: the height of the widget

Returns the height that has currently been allocated to widget. This function is intended to be used when implementing handlers for the Widget::draw function.

getAllocatedSize

data WidgetGetAllocatedSizeMethodInfo

Instances

((~) * signature (m (Rectangle, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAllocatedSizeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAllocatedSizeMethodInfo a -> signature -> s

widgetGetAllocatedSize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Rectangle, Int32)

Retrieves the widget’s allocated size.

This function returns the last values passed to widgetSizeAllocateWithBaseline. The value differs from the size returned in widgetGetAllocation in that functions like widgetSetHalign can adjust the allocation, but not the value returned by this function.

If a widget is not visible, its allocated size is 0.

Since: 3.20

getAllocatedWidth

data WidgetGetAllocatedWidthMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAllocatedWidthMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAllocatedWidthMethodInfo a -> signature -> s

widgetGetAllocatedWidth

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> m Int32

Returns: the width of the widget

Returns the width that has currently been allocated to widget. This function is intended to be used when implementing handlers for the Widget::draw function.

getAllocation

data WidgetGetAllocationMethodInfo

Instances

((~) * signature (m Rectangle), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAllocationMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAllocationMethodInfo a -> signature -> s

widgetGetAllocation

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Rectangle

Retrieves the widget’s allocation.

Note, when implementing a Container: a widget’s allocation will be its “adjusted” allocation, that is, the widget’s parent container typically calls widgetSizeAllocate with an allocation, and that allocation is then adjusted (to handle margin and alignment for example) before assignment to the widget. widgetGetAllocation returns the adjusted allocation that was actually assigned to the widget. The adjusted allocation is guaranteed to be completely contained within the widgetSizeAllocate allocation, however. So a Container is guaranteed that its children stay inside the assigned bounds, but not that they have exactly the bounds the container assigned. There is no way to get the original allocation assigned by widgetSizeAllocate, since it isn’t stored; if a container implementation needs that information it will have to track it itself.

Since: 2.18

getAncestor

data WidgetGetAncestorMethodInfo

Instances

((~) * signature (GType -> m (Maybe Widget)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAncestorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAncestorMethodInfo a -> signature -> s

widgetGetAncestor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> GType

widgetType: ancestor type

-> m (Maybe Widget)

Returns: the ancestor widget, or Nothing if not found

Gets the first ancestor of widget with type widgetType. For example, gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets the first Box that’s an ancestor of widget. No reference will be added to the returned widget; it should not be unreferenced. See note about checking for a toplevel Window in the docs for widgetGetToplevel.

Note that unlike widgetIsAncestor, widgetGetAncestor considers widget to be an ancestor of itself.

getAppPaintable

data WidgetGetAppPaintableMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetAppPaintableMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetAppPaintableMethodInfo a -> signature -> s

widgetGetAppPaintable

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is app paintable

Determines whether the application intends to draw on the widget in an Widget::draw handler.

See widgetSetAppPaintable

Since: 2.18

getCanDefault

data WidgetGetCanDefaultMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetCanDefaultMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetCanDefaultMethodInfo a -> signature -> s

widgetGetCanDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget can be a default widget, False otherwise

Determines whether widget can be a default widget. See widgetSetCanDefault.

Since: 2.18

getCanFocus

data WidgetGetCanFocusMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetCanFocusMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetCanFocusMethodInfo a -> signature -> s

widgetGetCanFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget can own the input focus, False otherwise

Determines whether widget can own the input focus. See widgetSetCanFocus.

Since: 2.18

getChildRequisition

data WidgetGetChildRequisitionMethodInfo

Instances

((~) * signature (m Requisition), MonadIO m, IsWidget a) => MethodInfo * WidgetGetChildRequisitionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetChildRequisitionMethodInfo a -> signature -> s

widgetGetChildRequisition

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Requisition

Deprecated: (Since version 3.0)Use widgetGetPreferredSize instead.

This function is only for use in widget implementations. Obtains widget->requisition, unless someone has forced a particular geometry on the widget (e.g. with widgetSetSizeRequest), in which case it returns that geometry instead of the widget's requisition.

This function differs from widgetSizeRequest in that it retrieves the last size request value from widget->requisition, while widgetSizeRequest actually calls the "size_request" method on widget to compute the size request and fill in widget->requisition, and only then returns widget->requisition.

Because this function does not call the “size_request” method, it can only be used when you know that widget->requisition is up-to-date, that is, widgetSizeRequest has been called since the last time a resize was queued. In general, only container implementations have this information; applications should use widgetSizeRequest.

getChildVisible

data WidgetGetChildVisibleMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetChildVisibleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetChildVisibleMethodInfo a -> signature -> s

widgetGetChildVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is mapped with the parent.

Gets the value set with widgetSetChildVisible. If you feel a need to use this function, your code probably needs reorganization.

This function is only useful for container implementations and never should be called by an application.

getClip

data WidgetGetClipMethodInfo

Instances

((~) * signature (m Rectangle), MonadIO m, IsWidget a) => MethodInfo * WidgetGetClipMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetClipMethodInfo a -> signature -> s

widgetGetClip

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Rectangle

Retrieves the widget’s clip area.

The clip area is the area in which all of widget's drawing will happen. Other toolkits call it the bounding box.

Historically, in GTK+ the clip area has been equal to the allocation retrieved via widgetGetAllocation.

Since: 3.14

getClipboard

data WidgetGetClipboardMethodInfo

Instances

((~) * signature (Atom -> m Clipboard), MonadIO m, IsWidget a) => MethodInfo * WidgetGetClipboardMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetClipboardMethodInfo a -> signature -> s

widgetGetClipboard

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Atom

selection: a Atom which identifies the clipboard to use. GDK_SELECTION_CLIPBOARD gives the default clipboard. Another common value is GDK_SELECTION_PRIMARY, which gives the primary X selection.

-> m Clipboard

Returns: the appropriate clipboard object. If no clipboard already exists, a new one will be created. Once a clipboard object has been created, it is persistent for all time.

Returns the clipboard object for the given selection to be used with widget. widget must have a Display associated with it, so must be attached to a toplevel window.

Since: 2.2

getCompositeName

data WidgetGetCompositeNameMethodInfo

Instances

((~) * signature (m Text), MonadIO m, IsWidget a) => MethodInfo * WidgetGetCompositeNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetCompositeNameMethodInfo a -> signature -> s

widgetGetCompositeName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Text

Returns: the composite name of widget, or Nothing if widget is not a composite child. The string should be freed when it is no longer needed.

Deprecated: (Since version 3.10)Use widgetClassSetTemplate, or don’t use this API at all.

Obtains the composite name of a widget.

getDefaultDirection

widgetGetDefaultDirection

Arguments

:: (HasCallStack, MonadIO m)

=> m TextDirection

Returns: the current default direction.

Obtains the current default reading direction. See widgetSetDefaultDirection.

getDefaultStyle

widgetGetDefaultStyle

Arguments

:: (HasCallStack, MonadIO m)

=> m Style

Returns: the default style. This Style object is owned by GTK+ and should not be modified or freed.

Deprecated: (Since version 3.0)Use StyleContext instead, and cssProviderGetDefault to obtain a StyleProvider with the default widget style information.

Returns the default style used by all widgets initially.

getDeviceEnabled

data WidgetGetDeviceEnabledMethodInfo

Instances

((~) * signature (b -> m Bool), MonadIO m, IsWidget a, IsDevice b) => MethodInfo * WidgetGetDeviceEnabledMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetDeviceEnabledMethodInfo a -> signature -> s

widgetGetDeviceEnabled

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: a Widget

-> b

device: a Device

-> m Bool

Returns: True is device is enabled for widget

Returns whether device can interact with widget and its children. See widgetSetDeviceEnabled.

Since: 3.0

getDeviceEvents

data WidgetGetDeviceEventsMethodInfo

Instances

((~) * signature (b -> m [EventMask]), MonadIO m, IsWidget a, IsDevice b) => MethodInfo * WidgetGetDeviceEventsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetDeviceEventsMethodInfo a -> signature -> s

widgetGetDeviceEvents

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: a Widget

-> b

device: a Device

-> m [EventMask]

Returns: device event mask for widget

Returns the events mask for the widget corresponding to an specific device. These are the events that the widget will receive when device operates on it.

Since: 3.0

getDirection

data WidgetGetDirectionMethodInfo

Instances

((~) * signature (m TextDirection), MonadIO m, IsWidget a) => MethodInfo * WidgetGetDirectionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetDirectionMethodInfo a -> signature -> s

widgetGetDirection

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m TextDirection

Returns: the reading direction for the widget.

Gets the reading direction for a particular widget. See widgetSetDirection.

getDisplay

data WidgetGetDisplayMethodInfo

Instances

((~) * signature (m Display), MonadIO m, IsWidget a) => MethodInfo * WidgetGetDisplayMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetDisplayMethodInfo a -> signature -> s

widgetGetDisplay

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Display

Returns: the Display for the toplevel for this widget.

Get the Display for the toplevel window associated with this widget. This function can only be called after the widget has been added to a widget hierarchy with a Window at the top.

In general, you should only create display specific resources when a widget has been realized, and you should free those resources when the widget is unrealized.

Since: 2.2

getDoubleBuffered

data WidgetGetDoubleBufferedMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetDoubleBufferedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetDoubleBufferedMethodInfo a -> signature -> s

widgetGetDoubleBuffered

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is double buffered

Determines whether the widget is double buffered.

See widgetSetDoubleBuffered

Since: 2.18

getEvents

data WidgetGetEventsMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetEventsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetEventsMethodInfo a -> signature -> s

widgetGetEvents

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: event mask for widget

Returns the event mask (see EventMask) for the widget. These are the events that the widget will receive.

Note: Internally, the widget event mask will be the logical OR of the event mask set through widgetSetEvents or widgetAddEvents, and the event mask necessary to cater for every EventController created for the widget.

getFocusOnClick

data WidgetGetFocusOnClickMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetFocusOnClickMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetFocusOnClickMethodInfo a -> signature -> s

widgetGetFocusOnClick

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget should grab focus when it is clicked with the mouse.

Returns whether the widget should grab focus when it is clicked with the mouse. See widgetSetFocusOnClick.

Since: 3.20

getFontMap

data WidgetGetFontMapMethodInfo

Instances

((~) * signature (m (Maybe FontMap)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetFontMapMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetFontMapMethodInfo a -> signature -> s

widgetGetFontMap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe FontMap)

Returns: A FontMap, or Nothing

Gets the font map that has been set with widgetSetFontMap.

Since: 3.18

getFontOptions

data WidgetGetFontOptionsMethodInfo

Instances

((~) * signature (m (Maybe FontOptions)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetFontOptionsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetFontOptionsMethodInfo a -> signature -> s

widgetGetFontOptions

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe FontOptions)

Returns: the FontOptions or Nothing if not set

Returns the FontOptions used for Pango rendering. When not set, the defaults font options for the Screen will be used.

Since: 3.18

getFrameClock

data WidgetGetFrameClockMethodInfo

Instances

((~) * signature (m (Maybe FrameClock)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetFrameClockMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetFrameClockMethodInfo a -> signature -> s

widgetGetFrameClock

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe FrameClock)

Returns: a FrameClock, or NULL if widget is unrealized

Obtains the frame clock for a widget. The frame clock is a global “ticker” that can be used to drive animations and repaints. The most common reason to get the frame clock is to call frameClockGetFrameTime, in order to get a time to use for animating. For example you might record the start of the animation with an initial value from frameClockGetFrameTime, and then update the animation by calling frameClockGetFrameTime again during each repaint.

frameClockRequestPhase will result in a new frame on the clock, but won’t necessarily repaint any widgets. To repaint a widget, you have to use widgetQueueDraw which invalidates the widget (thus scheduling it to receive a draw on the next frame). widgetQueueDraw will also end up requesting a frame on the appropriate frame clock.

A widget’s frame clock will not change while the widget is mapped. Reparenting a widget (which implies a temporary unmap) can change the widget’s frame clock.

Unrealized widgets do not have a frame clock.

Since: 3.8

getHalign

data WidgetGetHalignMethodInfo

Instances

((~) * signature (m Align), MonadIO m, IsWidget a) => MethodInfo * WidgetGetHalignMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetHalignMethodInfo a -> signature -> s

widgetGetHalign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Align

Returns: the horizontal alignment of widget

Gets the value of the Widget:halign property.

For backwards compatibility reasons this method will never return AlignBaseline, but instead it will convert it to AlignFill. Baselines are not supported for horizontal alignment.

getHasTooltip

data WidgetGetHasTooltipMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetHasTooltipMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetHasTooltipMethodInfo a -> signature -> s

widgetGetHasTooltip

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: current value of has-tooltip on widget.

Returns the current value of the has-tooltip property. See Widget:has-tooltip for more information.

Since: 2.12

getHasWindow

data WidgetGetHasWindowMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetHasWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetHasWindowMethodInfo a -> signature -> s

widgetGetHasWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget has a window, False otherwise

Determines whether widget has a Window of its own. See widgetSetHasWindow.

Since: 2.18

getHexpand

data WidgetGetHexpandMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetHexpandMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetHexpandMethodInfo a -> signature -> s

widgetGetHexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether hexpand flag is set

Gets whether the widget would like any available extra horizontal space. When a user resizes a Window, widgets with expand=TRUE generally receive the extra space. For example, a list or scrollable area or document in your window would often be set to expand.

Containers should use widgetComputeExpand rather than this function, to see whether a widget, or any of its children, has the expand flag set. If any child of a widget wants to expand, the parent may ask to expand also.

This function only looks at the widget’s own hexpand flag, rather than computing whether the entire widget tree rooted at this widget wants to expand.

getHexpandSet

data WidgetGetHexpandSetMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetHexpandSetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetHexpandSetMethodInfo a -> signature -> s

widgetGetHexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether hexpand has been explicitly set

Gets whether widgetSetHexpand has been used to explicitly set the expand flag on this widget.

If hexpand is set, then it overrides any computed expand value based on child widgets. If hexpand is not set, then the expand value depends on whether any children of the widget would like to expand.

There are few reasons to use this function, but it’s here for completeness and consistency.

getMapped

data WidgetGetMappedMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetMappedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetMappedMethodInfo a -> signature -> s

widgetGetMapped

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is mapped, False otherwise.

Whether the widget is mapped.

Since: 2.20

getMarginBottom

data WidgetGetMarginBottomMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetMarginBottomMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetMarginBottomMethodInfo a -> signature -> s

widgetGetMarginBottom

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The bottom margin of widget

Gets the value of the Widget:margin-bottom property.

Since: 3.0

getMarginEnd

data WidgetGetMarginEndMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetMarginEndMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetMarginEndMethodInfo a -> signature -> s

widgetGetMarginEnd

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The end margin of widget

Gets the value of the Widget:margin-end property.

Since: 3.12

getMarginLeft

data WidgetGetMarginLeftMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetMarginLeftMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetMarginLeftMethodInfo a -> signature -> s

widgetGetMarginLeft

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The left margin of widget

Deprecated: (Since version 3.12)Use widgetGetMarginStart instead.

Gets the value of the Widget:margin-left property.

Since: 3.0

getMarginRight

data WidgetGetMarginRightMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetMarginRightMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetMarginRightMethodInfo a -> signature -> s

widgetGetMarginRight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The right margin of widget

Deprecated: (Since version 3.12)Use widgetGetMarginEnd instead.

Gets the value of the Widget:margin-right property.

Since: 3.0

getMarginStart

data WidgetGetMarginStartMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetMarginStartMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetMarginStartMethodInfo a -> signature -> s

widgetGetMarginStart

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The start margin of widget

Gets the value of the Widget:margin-start property.

Since: 3.12

getMarginTop

data WidgetGetMarginTopMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetMarginTopMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetMarginTopMethodInfo a -> signature -> s

widgetGetMarginTop

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The top margin of widget

Gets the value of the Widget:margin-top property.

Since: 3.0

getModifierMask

data WidgetGetModifierMaskMethodInfo

Instances

((~) * signature (ModifierIntent -> m [ModifierType]), MonadIO m, IsWidget a) => MethodInfo * WidgetGetModifierMaskMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetModifierMaskMethodInfo a -> signature -> s

widgetGetModifierMask

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> ModifierIntent

intent: the use case for the modifier mask

-> m [ModifierType]

Returns: the modifier mask used for intent.

Returns the modifier mask the widget’s windowing system backend uses for a particular purpose.

See keymapGetModifierMask.

Since: 3.4

getModifierStyle

data WidgetGetModifierStyleMethodInfo

Instances

((~) * signature (m RcStyle), MonadIO m, IsWidget a) => MethodInfo * WidgetGetModifierStyleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetModifierStyleMethodInfo a -> signature -> s

widgetGetModifierStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m RcStyle

Returns: the modifier style for the widget. This rc style is owned by the widget. If you want to keep a pointer to value this around, you must add a refcount using objectRef.

Deprecated: (Since version 3.0)Use StyleContext with a custom StyleProvider instead

Returns the current modifier style for the widget. (As set by widgetModifyStyle.) If no style has previously set, a new RcStyle will be created with all values unset, and set as the modifier style for the widget. If you make changes to this rc style, you must call widgetModifyStyle, passing in the returned rc style, to make sure that your changes take effect.

Caution: passing the style back to widgetModifyStyle will normally end up destroying it, because widgetModifyStyle copies the passed-in style and sets the copy as the new modifier style, thus dropping any reference to the old modifier style. Add a reference to the modifier style if you want to keep it alive.

getName

data WidgetGetNameMethodInfo

Instances

((~) * signature (m Text), MonadIO m, IsWidget a) => MethodInfo * WidgetGetNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetNameMethodInfo a -> signature -> s

widgetGetName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Text

Returns: name of the widget. This string is owned by GTK+ and should not be modified or freed

Retrieves the name of a widget. See widgetSetName for the significance of widget names.

getNoShowAll

data WidgetGetNoShowAllMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetNoShowAllMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetNoShowAllMethodInfo a -> signature -> s

widgetGetNoShowAll

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: the current value of the “no-show-all” property.

Returns the current value of the Widget:no-show-all property, which determines whether calls to widgetShowAll will affect this widget.

Since: 2.4

getOpacity

data WidgetGetOpacityMethodInfo

Instances

((~) * signature (m Double), MonadIO m, IsWidget a) => MethodInfo * WidgetGetOpacityMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetOpacityMethodInfo a -> signature -> s

widgetGetOpacity

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Double

Returns: the requested opacity for this widget.

Fetches the requested opacity for this widget. See widgetSetOpacity.

Since: 3.8

getPangoContext

data WidgetGetPangoContextMethodInfo

Instances

((~) * signature (m Context), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPangoContextMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPangoContextMethodInfo a -> signature -> s

widgetGetPangoContext

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Context

Returns: the Context for the widget.

Gets a Context with the appropriate font map, font description, and base direction for this widget. Unlike the context returned by widgetCreatePangoContext, this context is owned by the widget (it can be used until the screen for the widget changes or the widget is removed from its toplevel), and will be updated to match any changes to the widget’s attributes. This can be tracked by using the Widget::screen-changed signal on the widget.

getParent

data WidgetGetParentMethodInfo

Instances

((~) * signature (m (Maybe Widget)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetParentMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetParentMethodInfo a -> signature -> s

widgetGetParent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Widget)

Returns: the parent container of widget, or Nothing

Returns the parent container of widget.

getParentWindow

data WidgetGetParentWindowMethodInfo

Instances

((~) * signature (m Window), MonadIO m, IsWidget a) => MethodInfo * WidgetGetParentWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetParentWindowMethodInfo a -> signature -> s

widgetGetParentWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget.

-> m Window

Returns: the parent window of widget.

Gets widget’s parent window.

getPath

data WidgetGetPathMethodInfo

Instances

((~) * signature (m WidgetPath), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPathMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPathMethodInfo a -> signature -> s

widgetGetPath

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m WidgetPath

Returns: The WidgetPath representing widget

Returns the WidgetPath representing widget, if the widget is not connected to a toplevel widget, a partial path will be created.

getPointer

data WidgetGetPointerMethodInfo

Instances

((~) * signature (m (Int32, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPointerMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPointerMethodInfo a -> signature -> s

widgetGetPointer

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Int32, Int32)

Deprecated: (Since version 3.4)Use windowGetDevicePosition instead.

Obtains the location of the mouse pointer in widget coordinates. Widget coordinates are a bit odd; for historical reasons, they are defined as widget->window coordinates for widgets that return True for widgetGetHasWindow; and are relative to widget->allocation.x, widget->allocation.y otherwise.

getPreferredHeight

data WidgetGetPreferredHeightMethodInfo

Instances

((~) * signature (m (Int32, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPreferredHeightMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPreferredHeightMethodInfo a -> signature -> s

widgetGetPreferredHeight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> m (Int32, Int32)

Retrieves a widget’s initial minimum and natural height.

This call is specific to width-for-height requests.

The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself.

Since: 3.0

getPreferredHeightAndBaselineForWidth

data WidgetGetPreferredHeightAndBaselineForWidthMethodInfo

Instances

((~) * signature (Int32 -> m (Int32, Int32, Int32, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPreferredHeightAndBaselineForWidthMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPreferredHeightAndBaselineForWidthMethodInfo a -> signature -> s

widgetGetPreferredHeightAndBaselineForWidth

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> Int32

width: the width which is available for allocation, or -1 if none

-> m (Int32, Int32, Int32, Int32)

Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given the specified width, or the default height if width is -1. The baselines may be -1 which means that no baseline is requested for this widget.

The returned request will be modified by the GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods and by any GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself.

Since: 3.10

getPreferredHeightForWidth

data WidgetGetPreferredHeightForWidthMethodInfo

Instances

((~) * signature (Int32 -> m (Int32, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPreferredHeightForWidthMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPreferredHeightForWidthMethodInfo a -> signature -> s

widgetGetPreferredHeightForWidth

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> Int32

width: the width which is available for allocation

-> m (Int32, Int32)

Retrieves a widget’s minimum and natural height if it would be given the specified width.

The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself.

Since: 3.0

getPreferredSize

data WidgetGetPreferredSizeMethodInfo

Instances

((~) * signature (m (Requisition, Requisition)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPreferredSizeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPreferredSizeMethodInfo a -> signature -> s

widgetGetPreferredSize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> m (Requisition, Requisition)

Retrieves the minimum and natural size of a widget, taking into account the widget’s preference for height-for-width management.

This is used to retrieve a suitable size by container widgets which do not impose any restrictions on the child placement. It can be used to deduce toplevel window and menu sizes as well as child widgets in free-form containers such as GtkLayout.

Handle with care. Note that the natural height of a height-for-width widget will generally be a smaller size than the minimum height, since the required height for the natural width is generally smaller than the required height for the minimum width.

Use widgetGetPreferredHeightAndBaselineForWidth if you want to support baseline alignment.

Since: 3.0

getPreferredWidth

data WidgetGetPreferredWidthMethodInfo

Instances

((~) * signature (m (Int32, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPreferredWidthMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPreferredWidthMethodInfo a -> signature -> s

widgetGetPreferredWidth

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> m (Int32, Int32)

Retrieves a widget’s initial minimum and natural width.

This call is specific to height-for-width requests.

The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself.

Since: 3.0

getPreferredWidthForHeight

data WidgetGetPreferredWidthForHeightMethodInfo

Instances

((~) * signature (Int32 -> m (Int32, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetPreferredWidthForHeightMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetPreferredWidthForHeightMethodInfo a -> signature -> s

widgetGetPreferredWidthForHeight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> Int32

height: the height which is available for allocation

-> m (Int32, Int32)

Retrieves a widget’s minimum and natural width if it would be given the specified height.

The returned request will be modified by the GtkWidgetClass::adjust_size_request virtual method and by any GtkSizeGroups that have been applied. That is, the returned request is the one that should be used for layout, not necessarily the one returned by the widget itself.

Since: 3.0

getRealized

data WidgetGetRealizedMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetRealizedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetRealizedMethodInfo a -> signature -> s

widgetGetRealized

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is realized, False otherwise

Determines whether widget is realized.

Since: 2.20

getReceivesDefault

data WidgetGetReceivesDefaultMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetReceivesDefaultMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetReceivesDefaultMethodInfo a -> signature -> s

widgetGetReceivesDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget acts as the default widget when focused, False otherwise

Determines whether widget is always treated as the default widget within its toplevel when it has the focus, even if another widget is the default.

See widgetSetReceivesDefault.

Since: 2.18

getRequestMode

data WidgetGetRequestModeMethodInfo

Instances

((~) * signature (m SizeRequestMode), MonadIO m, IsWidget a) => MethodInfo * WidgetGetRequestModeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetRequestModeMethodInfo a -> signature -> s

widgetGetRequestMode

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> m SizeRequestMode

Returns: The SizeRequestMode preferred by widget.

Gets whether the widget prefers a height-for-width layout or a width-for-height layout.

Bin widgets generally propagate the preference of their child, container widgets need to request something either in context of their children or in context of their allocation capabilities.

Since: 3.0

getRequisition

data WidgetGetRequisitionMethodInfo

Instances

((~) * signature (m Requisition), MonadIO m, IsWidget a) => MethodInfo * WidgetGetRequisitionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetRequisitionMethodInfo a -> signature -> s

widgetGetRequisition

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Requisition

Deprecated: (Since version 3.0)The Requisition cache on the widget wasremoved, If you need to cache sizes across requests and allocations,add an explicit cache to the widget in question instead.

Retrieves the widget’s requisition.

This function should only be used by widget implementations in order to figure whether the widget’s requisition has actually changed after some internal state change (so that they can call widgetQueueResize instead of widgetQueueDraw).

Normally, widgetSizeRequest should be used.

Since: 2.20

getRootWindow

data WidgetGetRootWindowMethodInfo

Instances

((~) * signature (m Window), MonadIO m, IsWidget a) => MethodInfo * WidgetGetRootWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetRootWindowMethodInfo a -> signature -> s

widgetGetRootWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Window

Returns: the Window root window for the toplevel for this widget.

Deprecated: (Since version 3.12)Use screenGetRootWindow instead

Get the root window where this widget is located. This function can only be called after the widget has been added to a widget hierarchy with Window at the top.

The root window is useful for such purposes as creating a popup Window associated with the window. In general, you should only create display specific resources when a widget has been realized, and you should free those resources when the widget is unrealized.

Since: 2.2

getScaleFactor

data WidgetGetScaleFactorMethodInfo

Instances

((~) * signature (m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetGetScaleFactorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetScaleFactorMethodInfo a -> signature -> s

widgetGetScaleFactor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: the scale factor for widget

Retrieves the internal scale factor that maps from window coordinates to the actual device pixels. On traditional systems this is 1, on high density outputs, it can be a higher value (typically 2).

See windowGetScaleFactor.

Since: 3.10

getScreen

data WidgetGetScreenMethodInfo

Instances

((~) * signature (m Screen), MonadIO m, IsWidget a) => MethodInfo * WidgetGetScreenMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetScreenMethodInfo a -> signature -> s

widgetGetScreen

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Screen

Returns: the Screen for the toplevel for this widget.

Get the Screen from the toplevel window associated with this widget. This function can only be called after the widget has been added to a widget hierarchy with a Window at the top.

In general, you should only create screen specific resources when a widget has been realized, and you should free those resources when the widget is unrealized.

Since: 2.2

getSensitive

data WidgetGetSensitiveMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetSensitiveMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetSensitiveMethodInfo a -> signature -> s

widgetGetSensitive

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is sensitive

Returns the widget’s sensitivity (in the sense of returning the value that has been set using widgetSetSensitive).

The effective sensitivity of a widget is however determined by both its own and its parent widget’s sensitivity. See widgetIsSensitive.

Since: 2.18

getSettings

data WidgetGetSettingsMethodInfo

Instances

((~) * signature (m Settings), MonadIO m, IsWidget a) => MethodInfo * WidgetGetSettingsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetSettingsMethodInfo a -> signature -> s

widgetGetSettings

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Settings

Returns: the relevant Settings object

Gets the settings object holding the settings used for this widget.

Note that this function can only be called when the Widget is attached to a toplevel, since the settings object is specific to a particular Screen.

getSizeRequest

data WidgetGetSizeRequestMethodInfo

Instances

((~) * signature (m (Int32, Int32)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetSizeRequestMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetSizeRequestMethodInfo a -> signature -> s

widgetGetSizeRequest

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Int32, Int32)

Gets the size request that was explicitly set for the widget using widgetSetSizeRequest. A value of -1 stored in width or height indicates that that dimension has not been set explicitly and the natural requisition of the widget will be used instead. See widgetSetSizeRequest. To get the size a widget will actually request, call widgetGetPreferredSize instead of this function.

getState

data WidgetGetStateMethodInfo

Instances

((~) * signature (m StateType), MonadIO m, IsWidget a) => MethodInfo * WidgetGetStateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetStateMethodInfo a -> signature -> s

widgetGetState

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m StateType

Returns: the state of widget.

Deprecated: (Since version 3.0)Use widgetGetStateFlags instead.

Returns the widget’s state. See widgetSetState.

Since: 2.18

getStateFlags

data WidgetGetStateFlagsMethodInfo

Instances

((~) * signature (m [StateFlags]), MonadIO m, IsWidget a) => MethodInfo * WidgetGetStateFlagsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetStateFlagsMethodInfo a -> signature -> s

widgetGetStateFlags

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m [StateFlags]

Returns: The state flags for widget

Returns the widget state as a flag set. It is worth mentioning that the effective StateFlagsInsensitive state will be returned, that is, also based on parent insensitivity, even if widget itself is sensitive.

Also note that if you are looking for a way to obtain the StateFlags to pass to a StyleContext method, you should look at styleContextGetState.

Since: 3.0

getStyle

data WidgetGetStyleMethodInfo

Instances

((~) * signature (m Style), MonadIO m, IsWidget a) => MethodInfo * WidgetGetStyleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetStyleMethodInfo a -> signature -> s

widgetGetStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Style

Returns: the widget’s Style

Deprecated: (Since version 3.0)Use StyleContext instead

Simply an accessor function that returns widget->style.

getStyleContext

data WidgetGetStyleContextMethodInfo

Instances

((~) * signature (m StyleContext), MonadIO m, IsWidget a) => MethodInfo * WidgetGetStyleContextMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetStyleContextMethodInfo a -> signature -> s

widgetGetStyleContext

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m StyleContext

Returns: a StyleContext. This memory is owned by widget and must not be freed.

Returns the style context associated to widget. The returned object is guaranteed to be the same for the lifetime of widget.

getSupportMultidevice

data WidgetGetSupportMultideviceMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetSupportMultideviceMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetSupportMultideviceMethodInfo a -> signature -> s

widgetGetSupportMultidevice

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is multidevice aware.

Returns True if widget is multiple pointer aware. See widgetSetSupportMultidevice for more information.

getTemplateChild

data WidgetGetTemplateChildMethodInfo

Instances

((~) * signature (GType -> Text -> m Object), MonadIO m, IsWidget a) => MethodInfo * WidgetGetTemplateChildMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetTemplateChildMethodInfo a -> signature -> s

widgetGetTemplateChild

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget

-> GType

widgetType: The GType to get a template child for

-> Text

name: The “id” of the child defined in the template XML

-> m Object

Returns: The object built in the template XML with the id name

Fetch an object build from the template XML for widgetType in this widget instance.

This will only report children which were previously declared with widgetClassBindTemplateChildFull or one of its variants.

This function is only meant to be called for code which is private to the widgetType which declared the child and is meant for language bindings which cannot easily make use of the GObject structure offsets.

getTooltipMarkup

data WidgetGetTooltipMarkupMethodInfo

Instances

((~) * signature (m (Maybe Text)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetTooltipMarkupMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetTooltipMarkupMethodInfo a -> signature -> s

widgetGetTooltipMarkup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Text)

Returns: the tooltip text, or Nothing. You should free the returned string with free when done.

Gets the contents of the tooltip for widget.

Since: 2.12

getTooltipText

data WidgetGetTooltipTextMethodInfo

Instances

((~) * signature (m (Maybe Text)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetTooltipTextMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetTooltipTextMethodInfo a -> signature -> s

widgetGetTooltipText

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Text)

Returns: the tooltip text, or Nothing. You should free the returned string with free when done.

Gets the contents of the tooltip for widget.

Since: 2.12

getTooltipWindow

data WidgetGetTooltipWindowMethodInfo

Instances

((~) * signature (m Window), MonadIO m, IsWidget a) => MethodInfo * WidgetGetTooltipWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetTooltipWindowMethodInfo a -> signature -> s

widgetGetTooltipWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Window

Returns: The Window of the current tooltip.

Returns the Window of the current tooltip. This can be the GtkWindow created by default, or the custom tooltip window set using widgetSetTooltipWindow.

Since: 2.12

getToplevel

data WidgetGetToplevelMethodInfo

Instances

((~) * signature (m Widget), MonadIO m, IsWidget a) => MethodInfo * WidgetGetToplevelMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetToplevelMethodInfo a -> signature -> s

widgetGetToplevel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Widget

Returns: the topmost ancestor of widget, or widget itself if there’s no ancestor.

This function returns the topmost widget in the container hierarchy widget is a part of. If widget has no parent widgets, it will be returned as the topmost widget. No reference will be added to the returned widget; it should not be unreferenced.

Note the difference in behavior vs. widgetGetAncestor; gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) would return Nothing if widget wasn’t inside a toplevel window, and if the window was inside a Window-derived widget which was in turn inside the toplevel Window. While the second case may seem unlikely, it actually happens when a Plug is embedded inside a Socket within the same application.

To reliably find the toplevel Window, use widgetGetToplevel and call widgetIsToplevel on the result.

C code

GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (gtk_widget_is_toplevel (toplevel))
  {
    // Perform action on toplevel.
  }

getValign

data WidgetGetValignMethodInfo

Instances

((~) * signature (m Align), MonadIO m, IsWidget a) => MethodInfo * WidgetGetValignMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetValignMethodInfo a -> signature -> s

widgetGetValign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Align

Returns: the vertical alignment of widget, ignoring baseline alignment

Gets the value of the Widget:valign property.

For backwards compatibility reasons this method will never return AlignBaseline, but instead it will convert it to AlignFill. If your widget want to support baseline aligned children it must use widgetGetValignWithBaseline, or g_object_get (widget, "valign", &value, NULL), which will also report the true value.

getValignWithBaseline

data WidgetGetValignWithBaselineMethodInfo

Instances

((~) * signature (m Align), MonadIO m, IsWidget a) => MethodInfo * WidgetGetValignWithBaselineMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetValignWithBaselineMethodInfo a -> signature -> s

widgetGetValignWithBaseline

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Align

Returns: the vertical alignment of widget

Gets the value of the Widget:valign property, including AlignBaseline.

Since: 3.10

getVexpand

data WidgetGetVexpandMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetVexpandMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetVexpandMethodInfo a -> signature -> s

widgetGetVexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether vexpand flag is set

Gets whether the widget would like any available extra vertical space.

See widgetGetHexpand for more detail.

getVexpandSet

data WidgetGetVexpandSetMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetVexpandSetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetVexpandSetMethodInfo a -> signature -> s

widgetGetVexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether vexpand has been explicitly set

Gets whether widgetSetVexpand has been used to explicitly set the expand flag on this widget.

See widgetGetHexpandSet for more detail.

getVisible

data WidgetGetVisibleMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetGetVisibleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetVisibleMethodInfo a -> signature -> s

widgetGetVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is visible

Determines whether the widget is visible. If you want to take into account whether the widget’s parent is also marked as visible, use widgetIsVisible instead.

This function does not check if the widget is obscured in any way.

See widgetSetVisible.

Since: 2.18

getVisual

data WidgetGetVisualMethodInfo

Instances

((~) * signature (m Visual), MonadIO m, IsWidget a) => MethodInfo * WidgetGetVisualMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetVisualMethodInfo a -> signature -> s

widgetGetVisual

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Visual

Returns: the visual for widget

Gets the visual that will be used to render widget.

getWindow

data WidgetGetWindowMethodInfo

Instances

((~) * signature (m (Maybe Window)), MonadIO m, IsWidget a) => MethodInfo * WidgetGetWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGetWindowMethodInfo a -> signature -> s

widgetGetWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Window)

Returns: widget’s window.

Returns the widget’s window if it is realized, Nothing otherwise

Since: 2.14

grabAdd

data WidgetGrabAddMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetGrabAddMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGrabAddMethodInfo a -> signature -> s

widgetGrabAdd

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: The widget that grabs keyboard and pointer events

-> m ()

Makes widget the current grabbed widget.

This means that interaction with other widgets in the same application is blocked and mouse as well as keyboard events are delivered to this widget.

If widget is not sensitive, it is not set as the current grabbed widget and this function does nothing.

grabDefault

data WidgetGrabDefaultMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetGrabDefaultMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGrabDefaultMethodInfo a -> signature -> s

widgetGrabDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Causes widget to become the default widget. widget must be able to be a default widget; typically you would ensure this yourself by calling widgetSetCanDefault with a True value. The default widget is activated when the user presses Enter in a window. Default widgets must be activatable, that is, widgetActivate should affect them. Note that Entry widgets require the “activates-default” property set to True before they activate the default widget when Enter is pressed and the Entry is focused.

grabFocus

data WidgetGrabFocusMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetGrabFocusMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGrabFocusMethodInfo a -> signature -> s

widgetGrabFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Causes widget to have the keyboard focus for the Window it's inside. widget must be a focusable widget, such as a Entry; something like Frame won’t work.

More precisely, it must have the GTK_CAN_FOCUS flag set. Use widgetSetCanFocus to modify that flag.

The widget also needs to be realized and mapped. This is indicated by the related signals. Grabbing the focus immediately after creating the widget will likely fail and cause critical warnings.

grabRemove

data WidgetGrabRemoveMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetGrabRemoveMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetGrabRemoveMethodInfo a -> signature -> s

widgetGrabRemove

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: The widget which gives up the grab

-> m ()

Removes the grab from the given widget.

You have to pair calls to widgetGrabAdd and widgetGrabRemove.

If widget does not have the grab, this function does nothing.

hasDefault

data WidgetHasDefaultMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetHasDefaultMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHasDefaultMethodInfo a -> signature -> s

widgetHasDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is the current default widget within its toplevel, False otherwise

Determines whether widget is the current default widget within its toplevel. See widgetSetCanDefault.

Since: 2.18

hasFocus

data WidgetHasFocusMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetHasFocusMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHasFocusMethodInfo a -> signature -> s

widgetHasFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget has the global input focus.

Determines if the widget has the global input focus. See widgetIsFocus for the difference between having the global input focus, and only having the focus within a toplevel.

Since: 2.18

hasGrab

data WidgetHasGrabMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetHasGrabMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHasGrabMethodInfo a -> signature -> s

widgetHasGrab

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is in the grab_widgets stack

Determines whether the widget is currently grabbing events, so it is the only widget receiving input events (keyboard and mouse).

See also widgetGrabAdd.

Since: 2.18

hasRcStyle

data WidgetHasRcStyleMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetHasRcStyleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHasRcStyleMethodInfo a -> signature -> s

widgetHasRcStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget has been looked up through the rc mechanism, False otherwise.

Deprecated: (Since version 3.0)Use StyleContext instead

Determines if the widget style has been looked up through the rc mechanism.

Since: 2.20

hasScreen

data WidgetHasScreenMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetHasScreenMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHasScreenMethodInfo a -> signature -> s

widgetHasScreen

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if there is a Screen associated with the widget.

Checks whether there is a Screen is associated with this widget. All toplevel widgets have an associated screen, and all widgets added into a hierarchy with a toplevel window at the top.

Since: 2.2

hasVisibleFocus

data WidgetHasVisibleFocusMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetHasVisibleFocusMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHasVisibleFocusMethodInfo a -> signature -> s

widgetHasVisibleFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget should display a “focus rectangle”

Determines if the widget should show a visible indication that it has the global input focus. This is a convenience function for use in ::draw handlers that takes into account whether focus indication should currently be shown in the toplevel window of widget. See windowGetFocusVisible for more information about focus indication.

To find out if the widget has the global input focus, use widgetHasFocus.

Since: 3.2

hide

data WidgetHideMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetHideMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHideMethodInfo a -> signature -> s

widgetHide

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Reverses the effects of widgetShow, causing the widget to be hidden (invisible to the user).

hideOnDelete

data WidgetHideOnDeleteMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetHideOnDeleteMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetHideOnDeleteMethodInfo a -> signature -> s

widgetHideOnDelete

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True

Utility function; intended to be connected to the Widget::delete-event signal on a Window. The function calls widgetHide on its argument, then returns True. If connected to ::delete-event, the result is that clicking the close button for a window (on the window frame, top right corner usually) will hide but not destroy the window. By default, GTK+ destroys windows when ::delete-event is received.

inDestruction

data WidgetInDestructionMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetInDestructionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetInDestructionMethodInfo a -> signature -> s

widgetInDestruction

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is being destroyed

Returns whether the widget is currently being destroyed. This information can sometimes be used to avoid doing unnecessary work.

initTemplate

data WidgetInitTemplateMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetInitTemplateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetInitTemplateMethodInfo a -> signature -> s

widgetInitTemplate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Creates and initializes child widgets defined in templates. This function must be called in the instance initializer for any class which assigned itself a template using widgetClassSetTemplate

It is important to call this function in the instance initializer of a Widget subclass and not in Object.constructed() or Object.constructor() for two reasons.

One reason is that generally derived widgets will assume that parent class composite widgets have been created in their instance initializers.

Another reason is that when calling g_object_new() on a widget with composite templates, it’s important to build the composite widgets before the construct properties are set. Properties passed to g_object_new() should take precedence over properties set in the private template XML.

Since: 3.10

inputShapeCombineRegion

data WidgetInputShapeCombineRegionMethodInfo

Instances

((~) * signature (Maybe Region -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetInputShapeCombineRegionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetInputShapeCombineRegionMethodInfo a -> signature -> s

widgetInputShapeCombineRegion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Region

region: shape to be added, or Nothing to remove an existing shape

-> m ()

Sets an input shape for this widget’s GDK window. This allows for windows which react to mouse click in a nonrectangular region, see windowInputShapeCombineRegion for more information.

Since: 3.0

insertActionGroup

data WidgetInsertActionGroupMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m ()), MonadIO m, IsWidget a, IsActionGroup b) => MethodInfo * WidgetInsertActionGroupMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetInsertActionGroupMethodInfo a -> signature -> s

widgetInsertActionGroup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsActionGroup b)

=> a

widget: a Widget

-> Text

name: the prefix for actions in group

-> Maybe b

group: a ActionGroup, or Nothing

-> m ()

Inserts group into widget. Children of widget that implement Actionable can then be associated with actions in group by setting their “action-name” to prefix.action-name.

If group is Nothing, a previously inserted group for name is removed from widget.

Since: 3.6

intersect

data WidgetIntersectMethodInfo

Instances

((~) * signature (Rectangle -> m (Bool, Rectangle)), MonadIO m, IsWidget a) => MethodInfo * WidgetIntersectMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIntersectMethodInfo a -> signature -> s

widgetIntersect

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Rectangle

area: a rectangle

-> m (Bool, Rectangle)

Returns: True if there was an intersection

Computes the intersection of a widget’s area and area, storing the intersection in intersection, and returns True if there was an intersection. intersection may be Nothing if you’re only interested in whether there was an intersection.

isAncestor

data WidgetIsAncestorMethodInfo

Instances

((~) * signature (b -> m Bool), MonadIO m, IsWidget a, IsWidget b) => MethodInfo * WidgetIsAncestorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIsAncestorMethodInfo a -> signature -> s

widgetIsAncestor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

ancestor: another Widget

-> m Bool

Returns: True if ancestor contains widget as a child, grandchild, great grandchild, etc.

Determines whether widget is somewhere inside ancestor, possibly with intermediate containers.

isComposited

data WidgetIsCompositedMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetIsCompositedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIsCompositedMethodInfo a -> signature -> s

widgetIsComposited

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget can rely on its alpha channel being drawn correctly.

Deprecated: (Since version 3.22)Use screenIsComposited instead.

Whether widget can rely on having its alpha channel drawn correctly. On X11 this function returns whether a compositing manager is running for widget’s screen.

Please note that the semantics of this call will change in the future if used on a widget that has a composited window in its hierarchy (as set by windowSetComposited).

Since: 2.10

isDrawable

data WidgetIsDrawableMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetIsDrawableMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIsDrawableMethodInfo a -> signature -> s

widgetIsDrawable

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is drawable, False otherwise

Determines whether widget can be drawn to. A widget can be drawn to if it is mapped and visible.

Since: 2.18

isFocus

data WidgetIsFocusMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetIsFocusMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIsFocusMethodInfo a -> signature -> s

widgetIsFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is the focus widget.

Determines if the widget is the focus widget within its toplevel. (This does not mean that the Widget:has-focus property is necessarily set; Widget:has-focus will only be set if the toplevel widget additionally has the global input focus.)

isSensitive

data WidgetIsSensitiveMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetIsSensitiveMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIsSensitiveMethodInfo a -> signature -> s

widgetIsSensitive

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is effectively sensitive

Returns the widget’s effective sensitivity, which means it is sensitive itself and also its parent widget is sensitive

Since: 2.18

isToplevel

data WidgetIsToplevelMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetIsToplevelMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIsToplevelMethodInfo a -> signature -> s

widgetIsToplevel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is a toplevel, False otherwise

Determines whether widget is a toplevel widget.

Currently only Window and Invisible (and out-of-process GtkPlugs) are toplevel widgets. Toplevel widgets have no parent widget.

Since: 2.18

isVisible

data WidgetIsVisibleMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetIsVisibleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetIsVisibleMethodInfo a -> signature -> s

widgetIsVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget and all its parents are visible

Determines whether the widget and all its parents are marked as visible.

This function does not check if the widget is obscured in any way.

See also widgetGetVisible and widgetSetVisible

Since: 3.8

keynavFailed

data WidgetKeynavFailedMethodInfo

Instances

((~) * signature (DirectionType -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetKeynavFailedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetKeynavFailedMethodInfo a -> signature -> s

widgetKeynavFailed

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> DirectionType

direction: direction of focus movement

-> m Bool

Returns: True if stopping keyboard navigation is fine, False if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).

This function should be called whenever keyboard navigation within a single widget hits a boundary. The function emits the Widget::keynav-failed signal on the widget and its return value should be interpreted in a way similar to the return value of widgetChildFocus:

When True is returned, stay in the widget, the failed keyboard navigation is OK and/or there is nowhere we can/should move the focus to.

When False is returned, the caller should continue with keyboard navigation outside the widget, e.g. by calling widgetChildFocus on the widget’s toplevel.

The default ::keynav-failed handler returns True for DirectionTypeTabForward and DirectionTypeTabBackward. For the other values of DirectionType it returns False.

Whenever the default handler returns True, it also calls widgetErrorBell to notify the user of the failed keyboard navigation.

A use case for providing an own implementation of ::keynav-failed (either by connecting to it or by overriding it) would be a row of Entry widgets where the user should be able to navigate the entire row with the cursor keys, as e.g. known from user interfaces that require entering license keys.

Since: 2.12

listAccelClosures

data WidgetListAccelClosuresMethodInfo

Instances

((~) * signature (m [Closure]), MonadIO m, IsWidget a) => MethodInfo * WidgetListAccelClosuresMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetListAccelClosuresMethodInfo a -> signature -> s

widgetListAccelClosures

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: widget to list accelerator closures for

-> m [Closure]

Returns: a newly allocated List of closures

Lists the closures used by widget for accelerator group connections with accelGroupConnectByPath or accelGroupConnect. The closures can be used to monitor accelerator changes on widget, by connecting to the gtkAccelGroup::accel-changed signal of the AccelGroup of a closure which can be found out with accelGroupFromAccelClosure.

listActionPrefixes

data WidgetListActionPrefixesMethodInfo

Instances

((~) * signature (m [Text]), MonadIO m, IsWidget a) => MethodInfo * WidgetListActionPrefixesMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetListActionPrefixesMethodInfo a -> signature -> s

widgetListActionPrefixes

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget

-> m [Text]

Returns: a Nothing-terminated array of strings.

Retrieves a Nothing-terminated array of strings containing the prefixes of 'GI.Gio.Interfaces.ActionGroup.ActionGroup'\'s available to widget.

Since: 3.16

listMnemonicLabels

data WidgetListMnemonicLabelsMethodInfo

Instances

((~) * signature (m [Widget]), MonadIO m, IsWidget a) => MethodInfo * WidgetListMnemonicLabelsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetListMnemonicLabelsMethodInfo a -> signature -> s

widgetListMnemonicLabels

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m [Widget]

Returns: the list of mnemonic labels; free this list with g_list_free() when you are done with it.

Returns a newly allocated list of the widgets, normally labels, for which this widget is the target of a mnemonic (see for example, labelSetMnemonicWidget).

The widgets in the list are not individually referenced. If you want to iterate through the list and perform actions involving callbacks that might destroy the widgets, you must call g_list_foreach (result, (GFunc)g_object_ref, NULL) first, and then unref all the widgets afterwards.

Since: 2.4

map

data WidgetMapMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetMapMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetMapMethodInfo a -> signature -> s

widgetMap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Causes a widget to be mapped if it isn’t already.

mnemonicActivate

data WidgetMnemonicActivateMethodInfo

Instances

((~) * signature (Bool -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetMnemonicActivateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetMnemonicActivateMethodInfo a -> signature -> s

widgetMnemonicActivate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

groupCycling: True if there are other widgets with the same mnemonic

-> m Bool

Returns: True if the signal has been handled

Emits the Widget::mnemonic-activate signal.

The default handler for this signal activates the widget if groupCycling is False, and just grabs the focus if groupCycling is True.

modifyBase

data WidgetModifyBaseMethodInfo

Instances

((~) * signature (StateType -> Maybe Color -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetModifyBaseMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetModifyBaseMethodInfo a -> signature -> s

widgetModifyBase

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> StateType

state: the state for which to set the base color

-> Maybe Color

color: the color to assign (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetModifyBase.

-> m ()

Deprecated: (Since version 3.0)Use widgetOverrideBackgroundColor instead

Sets the base color for a widget in a particular state. All other style values are left untouched. The base color is the background color used along with the text color (see widgetModifyText) for widgets such as Entry and TextView. See also widgetModifyStyle.

Note that “no window” widgets (which have the @/GTK_NO_WINDOW/@
flag set) draw on their parent container’s window and thus may
not draw any background themselves. This is the case for e.g.
'GI.Gtk.Objects.Label.Label'.

To modify the background of such widgets, you have to set the
base color on their parent; if you want to set the background
of a rectangular area around a label, try placing the label in
a 'GI.Gtk.Objects.EventBox.EventBox' widget and setting the base color on that.

modifyBg

data WidgetModifyBgMethodInfo

Instances

((~) * signature (StateType -> Maybe Color -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetModifyBgMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetModifyBgMethodInfo a -> signature -> s

widgetModifyBg

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> StateType

state: the state for which to set the background color

-> Maybe Color

color: the color to assign (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetModifyBg.

-> m ()

Deprecated: (Since version 3.0)Use widgetOverrideBackgroundColor instead

Sets the background color for a widget in a particular state.

All other style values are left untouched. See also widgetModifyStyle.

Note that “no window” widgets (which have the @/GTK_NO_WINDOW/@
flag set) draw on their parent container’s window and thus may
not draw any background themselves. This is the case for e.g.
'GI.Gtk.Objects.Label.Label'.

To modify the background of such widgets, you have to set the
background color on their parent; if you want to set the background
of a rectangular area around a label, try placing the label in
a 'GI.Gtk.Objects.EventBox.EventBox' widget and setting the background color on that.

modifyCursor

data WidgetModifyCursorMethodInfo

Instances

((~) * signature (Maybe Color -> Maybe Color -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetModifyCursorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetModifyCursorMethodInfo a -> signature -> s

widgetModifyCursor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Color

primary: the color to use for primary cursor (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetModifyCursor.

-> Maybe Color

secondary: the color to use for secondary cursor (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetModifyCursor.

-> m ()

Deprecated: (Since version 3.0)Use widgetOverrideCursor instead.

Sets the cursor color to use in a widget, overriding the Widget cursor-color and secondary-cursor-color style properties.

All other style values are left untouched. See also widgetModifyStyle.

Since: 2.12

modifyFg

data WidgetModifyFgMethodInfo

Instances

((~) * signature (StateType -> Maybe Color -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetModifyFgMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetModifyFgMethodInfo a -> signature -> s

widgetModifyFg

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> StateType

state: the state for which to set the foreground color

-> Maybe Color

color: the color to assign (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetModifyFg.

-> m ()

Deprecated: (Since version 3.0)Use widgetOverrideColor instead

Sets the foreground color for a widget in a particular state.

All other style values are left untouched. See also widgetModifyStyle.

modifyFont

data WidgetModifyFontMethodInfo

Instances

((~) * signature (Maybe FontDescription -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetModifyFontMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetModifyFontMethodInfo a -> signature -> s

widgetModifyFont

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe FontDescription

fontDesc: the font description to use, or Nothing to undo the effect of previous calls to widgetModifyFont

-> m ()

Deprecated: (Since version 3.0)Use widgetOverrideFont instead

Sets the font to use for a widget.

All other style values are left untouched. See also widgetModifyStyle.

modifyStyle

data WidgetModifyStyleMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsRcStyle b) => MethodInfo * WidgetModifyStyleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetModifyStyleMethodInfo a -> signature -> s

widgetModifyStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsRcStyle b)

=> a

widget: a Widget

-> b

style: the RcStyle-struct holding the style modifications

-> m ()

Deprecated: (Since version 3.0)Use StyleContext with a custom StyleProvider instead

Modifies style values on the widget.

Modifications made using this technique take precedence over style values set via an RC file, however, they will be overridden if a style is explicitly set on the widget using widgetSetStyle. The RcStyle-struct is designed so each field can either be set or unset, so it is possible, using this function, to modify some style values and leave the others unchanged.

Note that modifications made with this function are not cumulative with previous calls to widgetModifyStyle or with such functions as widgetModifyFg. If you wish to retain previous values, you must first call widgetGetModifierStyle, make your modifications to the returned style, then call widgetModifyStyle with that style. On the other hand, if you first call widgetModifyStyle, subsequent calls to such functions widgetModifyFg will have a cumulative effect with the initial modifications.

modifyText

data WidgetModifyTextMethodInfo

Instances

((~) * signature (StateType -> Maybe Color -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetModifyTextMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetModifyTextMethodInfo a -> signature -> s

widgetModifyText

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> StateType

state: the state for which to set the text color

-> Maybe Color

color: the color to assign (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetModifyText.

-> m ()

Deprecated: (Since version 3.0)Use widgetOverrideColor instead

Sets the text color for a widget in a particular state.

All other style values are left untouched. The text color is the foreground color used along with the base color (see widgetModifyBase) for widgets such as Entry and TextView. See also widgetModifyStyle.

overrideBackgroundColor

data WidgetOverrideBackgroundColorMethodInfo

Instances

((~) * signature ([StateFlags] -> Maybe RGBA -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetOverrideBackgroundColorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetOverrideBackgroundColorMethodInfo a -> signature -> s

widgetOverrideBackgroundColor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [StateFlags]

state: the state for which to set the background color

-> Maybe RGBA

color: the color to assign, or Nothing to undo the effect of previous calls to widgetOverrideBackgroundColor

-> m ()

Deprecated: (Since version 3.16)This function is not useful in the context of CSS-based rendering. If you wish to change the way a widget renders its background you should use a custom CSS style, through an application-specific StyleProvider and a CSS style class. You can also override the default drawing of a widget through the Widget::draw signal, and use Cairo to draw a specific color, regardless of the CSS style.

Sets the background color to use for a widget.

All other style values are left untouched. See widgetOverrideColor.

Since: 3.0

overrideColor

data WidgetOverrideColorMethodInfo

Instances

((~) * signature ([StateFlags] -> Maybe RGBA -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetOverrideColorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetOverrideColorMethodInfo a -> signature -> s

widgetOverrideColor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [StateFlags]

state: the state for which to set the color

-> Maybe RGBA

color: the color to assign, or Nothing to undo the effect of previous calls to widgetOverrideColor

-> m ()

Deprecated: (Since version 3.16)Use a custom style provider and style classes instead

Sets the color to use for a widget.

All other style values are left untouched.

This function does not act recursively. Setting the color of a container does not affect its children. Note that some widgets that you may not think of as containers, for instance GtkButtons, are actually containers.

This API is mostly meant as a quick way for applications to change a widget appearance. If you are developing a widgets library and intend this change to be themeable, it is better done by setting meaningful CSS classes in your widget/container implementation through styleContextAddClass.

This way, your widget library can install a CssProvider with the STYLE_PROVIDER_PRIORITY_FALLBACK priority in order to provide a default styling for those widgets that need so, and this theming may fully overridden by the user’s theme.

Note that for complex widgets this may bring in undesired results (such as uniform background color everywhere), in these cases it is better to fully style such widgets through a CssProvider with the STYLE_PROVIDER_PRIORITY_APPLICATION priority.

Since: 3.0

overrideCursor

data WidgetOverrideCursorMethodInfo

Instances

((~) * signature (Maybe RGBA -> Maybe RGBA -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetOverrideCursorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetOverrideCursorMethodInfo a -> signature -> s

widgetOverrideCursor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe RGBA

cursor: the color to use for primary cursor (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetOverrideCursor.

-> Maybe RGBA

secondaryCursor: the color to use for secondary cursor (does not need to be allocated), or Nothing to undo the effect of previous calls to of widgetOverrideCursor.

-> m ()

Deprecated: (Since version 3.16)This function is not useful in the context of CSS-based rendering. If you wish to change the color used to render the primary and secondary cursors you should use a custom CSS style, through an application-specific StyleProvider and a CSS style class.

Sets the cursor color to use in a widget, overriding the cursor-color and secondary-cursor-color style properties. All other style values are left untouched. See also widgetModifyStyle.

Note that the underlying properties have the Color type, so the alpha value in primary and secondary will be ignored.

Since: 3.0

overrideFont

data WidgetOverrideFontMethodInfo

Instances

((~) * signature (Maybe FontDescription -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetOverrideFontMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetOverrideFontMethodInfo a -> signature -> s

widgetOverrideFont

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe FontDescription

fontDesc: the font description to use, or Nothing to undo the effect of previous calls to widgetOverrideFont

-> m ()

Deprecated: (Since version 3.16)This function is not useful in the context of CSS-based rendering. If you wish to change the font a widget uses to render its text you should use a custom CSS style, through an application-specific StyleProvider and a CSS style class.

Sets the font to use for a widget. All other style values are left untouched. See widgetOverrideColor.

Since: 3.0

overrideSymbolicColor

data WidgetOverrideSymbolicColorMethodInfo

Instances

((~) * signature (Text -> Maybe RGBA -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetOverrideSymbolicColorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetOverrideSymbolicColorMethodInfo a -> signature -> s

widgetOverrideSymbolicColor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

name: the name of the symbolic color to modify

-> Maybe RGBA

color: the color to assign (does not need to be allocated), or Nothing to undo the effect of previous calls to widgetOverrideSymbolicColor

-> m ()

Deprecated: (Since version 3.16)This function is not useful in the context of CSS-based rendering. If you wish to change the color used to render symbolic icons you should use a custom CSS style, through an application-specific StyleProvider and a CSS style class.

Sets a symbolic color for a widget.

All other style values are left untouched. See widgetOverrideColor for overriding the foreground or background color.

Since: 3.0

path

data WidgetPathMethodInfo

Instances

((~) * signature (m (Word32, Text, Text)), MonadIO m, IsWidget a) => MethodInfo * WidgetPathMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetPathMethodInfo a -> signature -> s

widgetPath

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Word32, Text, Text)

Deprecated: (Since version 3.0)Use widgetGetPath instead

Obtains the full path to widget. The path is simply the name of a widget and all its parents in the container hierarchy, separated by periods. The name of a widget comes from widgetGetName. Paths are used to apply styles to a widget in gtkrc configuration files. Widget names are the type of the widget by default (e.g. “GtkButton”) or can be set to an application-specific value with widgetSetName. By setting the name of a widget, you allow users or theme authors to apply styles to that specific widget in their gtkrc file. pathReversedP fills in the path in reverse order, i.e. starting with widget’s name instead of starting with the name of widget’s outermost ancestor.

popCompositeChild

widgetPopCompositeChild :: (HasCallStack, MonadIO m) => m ()

Deprecated: (Since version 3.10)Use widgetClassSetTemplate, or don’t use this API at all.

Cancels the effect of a previous call to widgetPushCompositeChild.

pushCompositeChild

widgetPushCompositeChild :: (HasCallStack, MonadIO m) => m ()

Deprecated: (Since version 3.10)This API never really worked well and was mostly unused, nowwe have a more complete mechanism for composite children, see widgetClassSetTemplate.

Makes all newly-created widgets as composite children until the corresponding widgetPopCompositeChild call.

A composite child is a child that’s an implementation detail of the container it’s inside and should not be visible to people using the container. Composite children aren’t treated differently by GTK+ (but see containerForeach vs. containerForall), but e.g. GUI builders might want to treat them in a different way.

queueAllocate

data WidgetQueueAllocateMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetQueueAllocateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetQueueAllocateMethodInfo a -> signature -> s

widgetQueueAllocate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations.

Flags the widget for a rerun of the GtkWidgetClass::size_allocate function. Use this function instead of widgetQueueResize when the widget's size request didn't change but it wants to reposition its contents.

An example user of this function is widgetSetHalign.

Since: 3.20

queueComputeExpand

data WidgetQueueComputeExpandMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetQueueComputeExpandMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetQueueComputeExpandMethodInfo a -> signature -> s

widgetQueueComputeExpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Mark widget as needing to recompute its expand flags. Call this function when setting legacy expand child properties on the child of a container.

See widgetComputeExpand.

queueDraw

data WidgetQueueDrawMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetQueueDrawMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetQueueDrawMethodInfo a -> signature -> s

widgetQueueDraw

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Equivalent to calling widgetQueueDrawArea for the entire area of a widget.

queueDrawArea

data WidgetQueueDrawAreaMethodInfo

Instances

((~) * signature (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetQueueDrawAreaMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetQueueDrawAreaMethodInfo a -> signature -> s

widgetQueueDrawArea

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

x: x coordinate of upper-left corner of rectangle to redraw

-> Int32

y: y coordinate of upper-left corner of rectangle to redraw

-> Int32

width: width of region to draw

-> Int32

height: height of region to draw

-> m ()

Convenience function that calls widgetQueueDrawRegion on the region created from the given coordinates.

The region here is specified in widget coordinates. Widget coordinates are a bit odd; for historical reasons, they are defined as widget->window coordinates for widgets that return True for widgetGetHasWindow, and are relative to widget->allocation.x, widget->allocation.y otherwise.

width or height may be 0, in this case this function does nothing. Negative values for width and height are not allowed.

queueDrawRegion

data WidgetQueueDrawRegionMethodInfo

Instances

((~) * signature (Region -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetQueueDrawRegionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetQueueDrawRegionMethodInfo a -> signature -> s

widgetQueueDrawRegion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Region

region: region to draw

-> m ()

Invalidates the area of widget defined by region by calling windowInvalidateRegion on the widget’s window and all its child windows. Once the main loop becomes idle (after the current batch of events has been processed, roughly), the window will receive expose events for the union of all regions that have been invalidated.

Normally you would only use this function in widget implementations. You might also use it to schedule a redraw of a DrawingArea or some portion thereof.

Since: 3.0

queueResize

data WidgetQueueResizeMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetQueueResizeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetQueueResizeMethodInfo a -> signature -> s

widgetQueueResize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Flags a widget to have its size renegotiated; should be called when a widget for some reason has a new size request. For example, when you change the text in a Label, Label queues a resize to ensure there’s enough space for the new text.

Note that you cannot call widgetQueueResize on a widget from inside its implementation of the GtkWidgetClass::size_allocate virtual method. Calls to widgetQueueResize from inside GtkWidgetClass::size_allocate will be silently ignored.

queueResizeNoRedraw

data WidgetQueueResizeNoRedrawMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetQueueResizeNoRedrawMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetQueueResizeNoRedrawMethodInfo a -> signature -> s

widgetQueueResizeNoRedraw

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function works like widgetQueueResize, except that the widget is not invalidated.

Since: 2.4

realize

data WidgetRealizeMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetRealizeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRealizeMethodInfo a -> signature -> s

widgetRealize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Creates the GDK (windowing system) resources associated with a widget. For example, widget->window will be created when a widget is realized. Normally realization happens implicitly; if you show a widget and all its parent containers, then the widget will be realized and mapped automatically.

Realizing a widget requires all the widget’s parent widgets to be realized; calling widgetRealize realizes the widget’s parents in addition to widget itself. If a widget is not yet inside a toplevel window when you realize it, bad things will happen.

This function is primarily used in widget implementations, and isn’t very useful otherwise. Many times when you think you might need it, a better approach is to connect to a signal that will be called after the widget is realized automatically, such as Widget::draw. Or simply g_signal_connect () to the Widget::realize signal.

regionIntersect

data WidgetRegionIntersectMethodInfo

Instances

((~) * signature (Region -> m Region), MonadIO m, IsWidget a) => MethodInfo * WidgetRegionIntersectMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRegionIntersectMethodInfo a -> signature -> s

widgetRegionIntersect

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Region

region: a Region, in the same coordinate system as widget->allocation. That is, relative to widget->window for widgets which return False from widgetGetHasWindow; relative to the parent window of widget->window otherwise.

-> m Region

Returns: A newly allocated region holding the intersection of widget and region.

Deprecated: (Since version 3.14)Use widgetGetAllocation and cairo_region_intersect_rectangle() to get the same behavior.

Computes the intersection of a widget’s area and region, returning the intersection. The result may be empty, use cairo_region_is_empty() to check.

registerWindow

data WidgetRegisterWindowMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWindow b) => MethodInfo * WidgetRegisterWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRegisterWindowMethodInfo a -> signature -> s

widgetRegisterWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWindow b)

=> a

widget: a Widget

-> b

window: a Window

-> m ()

Registers a Window with the widget and sets it up so that the widget receives events for it. Call widgetUnregisterWindow when destroying the window.

Before 3.8 you needed to call windowSetUserData directly to set this up. This is now deprecated and you should use widgetRegisterWindow instead. Old code will keep working as is, although some new features like transparency might not work perfectly.

Since: 3.8

removeAccelerator

data WidgetRemoveAcceleratorMethodInfo

Instances

((~) * signature (b -> Word32 -> [ModifierType] -> m Bool), MonadIO m, IsWidget a, IsAccelGroup b) => MethodInfo * WidgetRemoveAcceleratorMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRemoveAcceleratorMethodInfo a -> signature -> s

widgetRemoveAccelerator

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b)

=> a

widget: widget to install an accelerator on

-> b

accelGroup: accel group for this widget

-> Word32

accelKey: GDK keyval of the accelerator

-> [ModifierType]

accelMods: modifier key combination of the accelerator

-> m Bool

Returns: whether an accelerator was installed and could be removed

Removes an accelerator from widget, previously installed with widgetAddAccelerator.

removeMnemonicLabel

data WidgetRemoveMnemonicLabelMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => MethodInfo * WidgetRemoveMnemonicLabelMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRemoveMnemonicLabelMethodInfo a -> signature -> s

widgetRemoveMnemonicLabel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

label: a Widget that was previously set as a mnemonic label for widget with widgetAddMnemonicLabel.

-> m ()

Removes a widget from the list of mnemonic labels for this widget. (See widgetListMnemonicLabels). The widget must have previously been added to the list with widgetAddMnemonicLabel.

Since: 2.4

removeTickCallback

data WidgetRemoveTickCallbackMethodInfo

Instances

((~) * signature (Word32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetRemoveTickCallbackMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRemoveTickCallbackMethodInfo a -> signature -> s

widgetRemoveTickCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Word32

id: an id returned by widgetAddTickCallback

-> m ()

Removes a tick callback previously registered with widgetAddTickCallback.

Since: 3.8

renderIcon

data WidgetRenderIconMethodInfo

Instances

((~) * signature (Text -> Int32 -> Maybe Text -> m (Maybe Pixbuf)), MonadIO m, IsWidget a) => MethodInfo * WidgetRenderIconMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRenderIconMethodInfo a -> signature -> s

widgetRenderIcon

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

stockId: a stock ID

-> Int32

size: a stock size (IconSize). A size of (GtkIconSize)-1 means render at the size of the source and don’t scale (if there are multiple source sizes, GTK+ picks one of the available sizes).

-> Maybe Text

detail: render detail to pass to theme engine

-> m (Maybe Pixbuf)

Returns: a new pixbuf, or Nothing if the stock ID wasn’t known

Deprecated: (Since version 3.0)Use widgetRenderIconPixbuf instead.

A convenience function that uses the theme settings for widget to look up stockId and render it to a pixbuf. stockId should be a stock icon ID such as STOCK_OPEN or STOCK_OK. size should be a size such as GTK_ICON_SIZE_MENU. detail should be a string that identifies the widget or code doing the rendering, so that theme engines can special-case rendering for that widget or code.

The pixels in the returned Pixbuf are shared with the rest of the application and should not be modified. The pixbuf should be freed after use with objectUnref.

renderIconPixbuf

data WidgetRenderIconPixbufMethodInfo

Instances

((~) * signature (Text -> Int32 -> m (Maybe Pixbuf)), MonadIO m, IsWidget a) => MethodInfo * WidgetRenderIconPixbufMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetRenderIconPixbufMethodInfo a -> signature -> s

widgetRenderIconPixbuf

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

stockId: a stock ID

-> Int32

size: a stock size (IconSize). A size of (GtkIconSize)-1 means render at the size of the source and don’t scale (if there are multiple source sizes, GTK+ picks one of the available sizes).

-> m (Maybe Pixbuf)

Returns: a new pixbuf, or Nothing if the stock ID wasn’t known

Deprecated: (Since version 3.10)Use iconThemeLoadIcon instead.

A convenience function that uses the theme engine and style settings for widget to look up stockId and render it to a pixbuf. stockId should be a stock icon ID such as STOCK_OPEN or STOCK_OK. size should be a size such as GTK_ICON_SIZE_MENU.

The pixels in the returned Pixbuf are shared with the rest of the application and should not be modified. The pixbuf should be freed after use with objectUnref.

Since: 3.0

reparent

data WidgetReparentMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => MethodInfo * WidgetReparentMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetReparentMethodInfo a -> signature -> s

widgetReparent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

newParent: a Container to move the widget into

-> m ()

Deprecated: (Since version 3.14)Use containerRemove and containerAdd.

Moves a widget from one Container to another, handling reference count issues to avoid destroying the widget.

resetRcStyles

data WidgetResetRcStylesMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetResetRcStylesMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetResetRcStylesMethodInfo a -> signature -> s

widgetResetRcStyles

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget.

-> m ()

Deprecated: (Since version 3.0)Use StyleContext instead, and widgetResetStyle

Reset the styles of widget and all descendents, so when they are looked up again, they get the correct values for the currently loaded RC file settings.

This function is not useful for applications.

resetStyle

data WidgetResetStyleMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetResetStyleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetResetStyleMethodInfo a -> signature -> s

widgetResetStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Updates the style context of widget and all descendants by updating its widget path. GtkContainers may want to use this on a child when reordering it in a way that a different style might apply to it. See also containerGetPathForChild.

Since: 3.0

sendExpose

data WidgetSendExposeMethodInfo

Instances

((~) * signature (Event -> m Int32), MonadIO m, IsWidget a) => MethodInfo * WidgetSendExposeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSendExposeMethodInfo a -> signature -> s

widgetSendExpose

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Event

event: a expose Event

-> m Int32

Returns: return from the event signal emission (True if the event was handled)

Deprecated: (Since version 3.22)Application and widget code should not handle expose events directly; invalidation should use the Widget API, and drawing should only happen inside Widget::draw implementations

Very rarely-used function. This function is used to emit an expose event on a widget. This function is not normally used directly. The only time it is used is when propagating an expose event to a windowless child widget (widgetGetHasWindow is False), and that is normally done using containerPropagateDraw.

If you want to force an area of a window to be redrawn, use windowInvalidateRect or windowInvalidateRegion. To cause the redraw to be done immediately, follow that call with a call to windowProcessUpdates.

sendFocusChange

data WidgetSendFocusChangeMethodInfo

Instances

((~) * signature (Event -> m Bool), MonadIO m, IsWidget a) => MethodInfo * WidgetSendFocusChangeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSendFocusChangeMethodInfo a -> signature -> s

widgetSendFocusChange

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Event

event: a Event of type GDK_FOCUS_CHANGE

-> m Bool

Returns: the return value from the event signal emission: True if the event was handled, and False otherwise

Sends the focus change event to widget

This function is not meant to be used by applications. The only time it should be used is when it is necessary for a Widget to assign focus to a widget that is semantically owned by the first widget even though it’s not a direct child - for instance, a search entry in a floating window similar to the quick search in TreeView.

An example of its usage is:

C code

 GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);

 fevent->focus_change.type = GDK_FOCUS_CHANGE;
 fevent->focus_change.in = TRUE;
 fevent->focus_change.window = _gtk_widget_get_window (widget);
 if (fevent->focus_change.window != NULL)
   g_object_ref (fevent->focus_change.window);

 gtk_widget_send_focus_change (widget, fevent);

 gdk_event_free (event);

Since: 2.20

setAccelPath

data WidgetSetAccelPathMethodInfo

Instances

((~) * signature (Maybe Text -> Maybe b -> m ()), MonadIO m, IsWidget a, IsAccelGroup b) => MethodInfo * WidgetSetAccelPathMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetAccelPathMethodInfo a -> signature -> s

widgetSetAccelPath

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b)

=> a

widget: a Widget

-> Maybe Text

accelPath: path used to look up the accelerator

-> Maybe b

accelGroup: a AccelGroup.

-> m ()

Given an accelerator group, accelGroup, and an accelerator path, accelPath, sets up an accelerator in accelGroup so whenever the key binding that is defined for accelPath is pressed, widget will be activated. This removes any accelerators (for any accelerator group) installed by previous calls to widgetSetAccelPath. Associating accelerators with paths allows them to be modified by the user and the modifications to be saved for future use. (See accelMapSave.)

This function is a low level function that would most likely be used by a menu creation system like UIManager. If you use UIManager, setting up accelerator paths will be done automatically.

Even when you you aren’t using UIManager, if you only want to set up accelerators on menu items menuItemSetAccelPath provides a somewhat more convenient interface.

Note that accelPath string will be stored in a GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with internStaticString.

setAllocation

data WidgetSetAllocationMethodInfo

Instances

((~) * signature (Rectangle -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetAllocationMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetAllocationMethodInfo a -> signature -> s

widgetSetAllocation

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Rectangle

allocation: a pointer to a GtkAllocation to copy from

-> m ()

Sets the widget’s allocation. This should not be used directly, but from within a widget’s size_allocate method.

The allocation set should be the “adjusted” or actual allocation. If you’re implementing a Container, you want to use widgetSizeAllocate instead of widgetSetAllocation. The GtkWidgetClass::adjust_size_allocation virtual method adjusts the allocation inside widgetSizeAllocate to create an adjusted allocation.

Since: 2.18

setAppPaintable

data WidgetSetAppPaintableMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetAppPaintableMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetAppPaintableMethodInfo a -> signature -> s

widgetSetAppPaintable

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

appPaintable: True if the application will paint on the widget

-> m ()

Sets whether the application intends to draw on the widget in an Widget::draw handler.

This is a hint to the widget and does not affect the behavior of the GTK+ core; many widgets ignore this flag entirely. For widgets that do pay attention to the flag, such as EventBox and Window, the effect is to suppress default themed drawing of the widget's background. (Children of the widget will still be drawn.) The application is then entirely responsible for drawing the widget background.

Note that the background is still drawn when the widget is mapped.

setCanDefault

data WidgetSetCanDefaultMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetCanDefaultMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetCanDefaultMethodInfo a -> signature -> s

widgetSetCanDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

canDefault: whether or not widget can be a default widget.

-> m ()

Specifies whether widget can be a default widget. See widgetGrabDefault for details about the meaning of “default”.

Since: 2.18

setCanFocus

data WidgetSetCanFocusMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetCanFocusMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetCanFocusMethodInfo a -> signature -> s

widgetSetCanFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

canFocus: whether or not widget can own the input focus.

-> m ()

Specifies whether widget can own the input focus. See widgetGrabFocus for actually setting the input focus on a widget.

Since: 2.18

setChildVisible

data WidgetSetChildVisibleMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetChildVisibleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetChildVisibleMethodInfo a -> signature -> s

widgetSetChildVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

isVisible: if True, widget should be mapped along with its parent.

-> m ()

Sets whether widget should be mapped along with its when its parent is mapped and widget has been shown with widgetShow.

The child visibility can be set for widget before it is added to a container with widgetSetParent, to avoid mapping children unnecessary before immediately unmapping them. However it will be reset to its default state of True when the widget is removed from a container.

Note that changing the child visibility of a widget does not queue a resize on the widget. Most of the time, the size of a widget is computed from all visible children, whether or not they are mapped. If this is not the case, the container can queue a resize itself.

This function is only useful for container implementations and never should be called by an application.

setClip

data WidgetSetClipMethodInfo

Instances

((~) * signature (Rectangle -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetClipMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetClipMethodInfo a -> signature -> s

widgetSetClip

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Rectangle

clip: a pointer to a GtkAllocation to copy from

-> m ()

Sets the widget’s clip. This must not be used directly, but from within a widget’s size_allocate method. It must be called after widgetSetAllocation (or after chaining up to the parent class), because that function resets the clip.

The clip set should be the area that widget draws on. If widget is a Container, the area must contain all children's clips.

If this function is not called by widget during a ::size-allocate handler, the clip will be set to widget's allocation.

Since: 3.14

setCompositeName

data WidgetSetCompositeNameMethodInfo

Instances

((~) * signature (Text -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetCompositeNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetCompositeNameMethodInfo a -> signature -> s

widgetSetCompositeName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget.

-> Text

name: the name to set

-> m ()

Deprecated: (Since version 3.10)Use widgetClassSetTemplate, or don’t use this API at all.

Sets a widgets composite name. The widget must be a composite child of its parent; see widgetPushCompositeChild.

setDefaultDirection

widgetSetDefaultDirection

Arguments

:: (HasCallStack, MonadIO m)

=> TextDirection

dir: the new default direction. This cannot be TextDirectionNone.

-> m ()

Sets the default reading direction for widgets where the direction has not been explicitly set by widgetSetDirection.

setDeviceEnabled

data WidgetSetDeviceEnabledMethodInfo

Instances

((~) * signature (b -> Bool -> m ()), MonadIO m, IsWidget a, IsDevice b) => MethodInfo * WidgetSetDeviceEnabledMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetDeviceEnabledMethodInfo a -> signature -> s

widgetSetDeviceEnabled

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: a Widget

-> b

device: a Device

-> Bool

enabled: whether to enable the device

-> m ()

Enables or disables a Device to interact with widget and all its children.

It does so by descending through the Window hierarchy and enabling the same mask that is has for core events (i.e. the one that windowGetEvents returns).

Since: 3.0

setDeviceEvents

data WidgetSetDeviceEventsMethodInfo

Instances

((~) * signature (b -> [EventMask] -> m ()), MonadIO m, IsWidget a, IsDevice b) => MethodInfo * WidgetSetDeviceEventsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetDeviceEventsMethodInfo a -> signature -> s

widgetSetDeviceEvents

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: a Widget

-> b

device: a Device

-> [EventMask]

events: event mask

-> m ()

Sets the device event mask (see EventMask) for a widget. The event mask determines which events a widget will receive from device. Keep in mind that different widgets have different default event masks, and by changing the event mask you may disrupt a widget’s functionality, so be careful. This function must be called while a widget is unrealized. Consider widgetAddDeviceEvents for widgets that are already realized, or if you want to preserve the existing event mask. This function can’t be used with windowless widgets (which return False from widgetGetHasWindow); to get events on those widgets, place them inside a EventBox and receive events on the event box.

Since: 3.0

setDirection

data WidgetSetDirectionMethodInfo

Instances

((~) * signature (TextDirection -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetDirectionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetDirectionMethodInfo a -> signature -> s

widgetSetDirection

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> TextDirection

dir: the new direction

-> m ()

Sets the reading direction on a particular widget. This direction controls the primary direction for widgets containing text, and also the direction in which the children of a container are packed. The ability to set the direction is present in order so that correct localization into languages with right-to-left reading directions can be done. Generally, applications will let the default reading direction present, except for containers where the containers are arranged in an order that is explicitly visual rather than logical (such as buttons for text justification).

If the direction is set to TextDirectionNone, then the value set by widgetSetDefaultDirection will be used.

setDoubleBuffered

data WidgetSetDoubleBufferedMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetDoubleBufferedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetDoubleBufferedMethodInfo a -> signature -> s

widgetSetDoubleBuffered

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

doubleBuffered: True to double-buffer a widget

-> m ()

Deprecated: (Since version 3.14)This function does not work under non-X11 backends or withnon-native windows.It should not be used in newly written code.

Widgets are double buffered by default; you can use this function to turn off the buffering. “Double buffered” simply means that windowBeginDrawFrame and windowEndDrawFrame are called automatically around expose events sent to the widget. windowBeginDrawFrame diverts all drawing to a widget's window to an offscreen buffer, and windowEndDrawFrame draws the buffer to the screen. The result is that users see the window update in one smooth step, and don’t see individual graphics primitives being rendered.

In very simple terms, double buffered widgets don’t flicker, so you would only use this function to turn off double buffering if you had special needs and really knew what you were doing.

Note: if you turn off double-buffering, you have to handle expose events, since even the clearing to the background color or pixmap will not happen automatically (as it is done in windowBeginDrawFrame).

In 3.10 GTK and GDK have been restructured for translucent drawing. Since then expose events for double-buffered widgets are culled into a single event to the toplevel GDK window. If you now unset double buffering, you will cause a separate rendering pass for every widget. This will likely cause rendering problems - in particular related to stacking - and usually increases rendering times significantly.

setEvents

data WidgetSetEventsMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetEventsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetEventsMethodInfo a -> signature -> s

widgetSetEvents

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

events: event mask

-> m ()

Sets the event mask (see EventMask) for a widget. The event mask determines which events a widget will receive. Keep in mind that different widgets have different default event masks, and by changing the event mask you may disrupt a widget’s functionality, so be careful. This function must be called while a widget is unrealized. Consider widgetAddEvents for widgets that are already realized, or if you want to preserve the existing event mask. This function can’t be used with widgets that have no window. (See widgetGetHasWindow). To get events on those widgets, place them inside a EventBox and receive events on the event box.

setFocusOnClick

data WidgetSetFocusOnClickMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetFocusOnClickMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetFocusOnClickMethodInfo a -> signature -> s

widgetSetFocusOnClick

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

focusOnClick: whether the widget should grab focus when clicked with the mouse

-> m ()

Sets whether the widget should grab focus when it is clicked with the mouse. Making mouse clicks not grab focus is useful in places like toolbars where you don’t want the keyboard focus removed from the main area of the application.

Since: 3.20

setFontMap

data WidgetSetFontMapMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsWidget a, IsFontMap b) => MethodInfo * WidgetSetFontMapMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetFontMapMethodInfo a -> signature -> s

widgetSetFontMap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsFontMap b)

=> a

widget: a Widget

-> Maybe b

fontMap: a FontMap, or Nothing to unset any previously set font map

-> m ()

Sets the font map to use for Pango rendering. When not set, the widget will inherit the font map from its parent.

Since: 3.18

setFontOptions

data WidgetSetFontOptionsMethodInfo

Instances

((~) * signature (Maybe FontOptions -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetFontOptionsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetFontOptionsMethodInfo a -> signature -> s

widgetSetFontOptions

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe FontOptions

options: a FontOptions, or Nothing to unset any previously set default font options.

-> m ()

Sets the FontOptions used for Pango rendering in this widget. When not set, the default font options for the Screen will be used.

Since: 3.18

setHalign

data WidgetSetHalignMethodInfo

Instances

((~) * signature (Align -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetHalignMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetHalignMethodInfo a -> signature -> s

widgetSetHalign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Align

align: the horizontal alignment

-> m ()

Sets the horizontal alignment of widget. See the Widget:halign property.

setHasTooltip

data WidgetSetHasTooltipMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetHasTooltipMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetHasTooltipMethodInfo a -> signature -> s

widgetSetHasTooltip

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

hasTooltip: whether or not widget has a tooltip.

-> m ()

Sets the has-tooltip property on widget to hasTooltip. See Widget:has-tooltip for more information.

Since: 2.12

setHasWindow

data WidgetSetHasWindowMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetHasWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetHasWindowMethodInfo a -> signature -> s

widgetSetHasWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

hasWindow: whether or not widget has a window.

-> m ()

Specifies whether widget has a Window of its own. Note that all realized widgets have a non-Nothing “window” pointer (widgetGetWindow never returns a Nothing window when a widget is realized), but for many of them it’s actually the Window of one of its parent widgets. Widgets that do not create a window for themselves in Widget::realize must announce this by calling this function with hasWindow = False.

This function should only be called by widget implementations, and they should call it in their init() function.

Since: 2.18

setHexpand

data WidgetSetHexpandMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetHexpandMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetHexpandMethodInfo a -> signature -> s

widgetSetHexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

expand: whether to expand

-> m ()

Sets whether the widget would like any available extra horizontal space. When a user resizes a Window, widgets with expand=TRUE generally receive the extra space. For example, a list or scrollable area or document in your window would often be set to expand.

Call this function to set the expand flag if you would like your widget to become larger horizontally when the window has extra room.

By default, widgets automatically expand if any of their children want to expand. (To see if a widget will automatically expand given its current children and state, call widgetComputeExpand. A container can decide how the expandability of children affects the expansion of the container by overriding the compute_expand virtual method on Widget.).

Setting hexpand explicitly with this function will override the automatic expand behavior.

This function forces the widget to expand or not to expand, regardless of children. The override occurs because widgetSetHexpand sets the hexpand-set property (see widgetSetHexpandSet) which causes the widget’s hexpand value to be used, rather than looking at children and widget state.

setHexpandSet

data WidgetSetHexpandSetMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetHexpandSetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetHexpandSetMethodInfo a -> signature -> s

widgetSetHexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

set: value for hexpand-set property

-> m ()

Sets whether the hexpand flag (see widgetGetHexpand) will be used.

The hexpand-set property will be set automatically when you call widgetSetHexpand to set hexpand, so the most likely reason to use this function would be to unset an explicit expand flag.

If hexpand is set, then it overrides any computed expand value based on child widgets. If hexpand is not set, then the expand value depends on whether any children of the widget would like to expand.

There are few reasons to use this function, but it’s here for completeness and consistency.

setMapped

data WidgetSetMappedMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetMappedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetMappedMethodInfo a -> signature -> s

widgetSetMapped

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

mapped: True to mark the widget as mapped

-> m ()

Marks the widget as being realized.

This function should only ever be called in a derived widget's “map” or “unmap” implementation.

Since: 2.20

setMarginBottom

data WidgetSetMarginBottomMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetMarginBottomMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetMarginBottomMethodInfo a -> signature -> s

widgetSetMarginBottom

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the bottom margin

-> m ()

Sets the bottom margin of widget. See the Widget:margin-bottom property.

Since: 3.0

setMarginEnd

data WidgetSetMarginEndMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetMarginEndMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetMarginEndMethodInfo a -> signature -> s

widgetSetMarginEnd

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the end margin

-> m ()

Sets the end margin of widget. See the Widget:margin-end property.

Since: 3.12

setMarginLeft

data WidgetSetMarginLeftMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetMarginLeftMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetMarginLeftMethodInfo a -> signature -> s

widgetSetMarginLeft

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the left margin

-> m ()

Deprecated: (Since version 3.12)Use widgetSetMarginStart instead.

Sets the left margin of widget. See the Widget:margin-left property.

Since: 3.0

setMarginRight

data WidgetSetMarginRightMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetMarginRightMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetMarginRightMethodInfo a -> signature -> s

widgetSetMarginRight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the right margin

-> m ()

Deprecated: (Since version 3.12)Use widgetSetMarginEnd instead.

Sets the right margin of widget. See the Widget:margin-right property.

Since: 3.0

setMarginStart

data WidgetSetMarginStartMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetMarginStartMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetMarginStartMethodInfo a -> signature -> s

widgetSetMarginStart

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the start margin

-> m ()

Sets the start margin of widget. See the Widget:margin-start property.

Since: 3.12

setMarginTop

data WidgetSetMarginTopMethodInfo

Instances

((~) * signature (Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetMarginTopMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetMarginTopMethodInfo a -> signature -> s

widgetSetMarginTop

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the top margin

-> m ()

Sets the top margin of widget. See the Widget:margin-top property.

Since: 3.0

setName

data WidgetSetNameMethodInfo

Instances

((~) * signature (Text -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetNameMethodInfo a -> signature -> s

widgetSetName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

name: name for the widget

-> m ()

Widgets can be named, which allows you to refer to them from a CSS file. You can apply a style to widgets with a particular name in the CSS file. See the documentation for the CSS syntax (on the same page as the docs for StyleContext).

Note that the CSS syntax has certain special characters to delimit and represent elements in a selector (period, #, >, *...), so using these will make your widget impossible to match by name. Any combination of alphanumeric symbols, dashes and underscores will suffice.

setNoShowAll

data WidgetSetNoShowAllMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetNoShowAllMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetNoShowAllMethodInfo a -> signature -> s

widgetSetNoShowAll

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

noShowAll: the new value for the “no-show-all” property

-> m ()

Sets the Widget:no-show-all property, which determines whether calls to widgetShowAll will affect this widget.

This is mostly for use in constructing widget hierarchies with externally controlled visibility, see UIManager.

Since: 2.4

setOpacity

data WidgetSetOpacityMethodInfo

Instances

((~) * signature (Double -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetOpacityMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetOpacityMethodInfo a -> signature -> s

widgetSetOpacity

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Double

opacity: desired opacity, between 0 and 1

-> m ()

Request the widget to be rendered partially transparent, with opacity 0 being fully transparent and 1 fully opaque. (Opacity values are clamped to the [0,1] range.). This works on both toplevel widget, and child widgets, although there are some limitations:

For toplevel widgets this depends on the capabilities of the windowing system. On X11 this has any effect only on X screens with a compositing manager running. See widgetIsComposited. On Windows it should work always, although setting a window’s opacity after the window has been shown causes it to flicker once on Windows.

For child widgets it doesn’t work if any affected widget has a native window, or disables double buffering.

Since: 3.8

setParent

data WidgetSetParentMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => MethodInfo * WidgetSetParentMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetParentMethodInfo a -> signature -> s

widgetSetParent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

parent: parent container

-> m ()

This function is useful only when implementing subclasses of Container. Sets the container as the parent of widget, and takes care of some details such as updating the state and style of the child to reflect its new location. The opposite function is widgetUnparent.

setParentWindow

data WidgetSetParentWindowMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWindow b) => MethodInfo * WidgetSetParentWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetParentWindowMethodInfo a -> signature -> s

widgetSetParentWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWindow b)

=> a

widget: a Widget.

-> b

parentWindow: the new parent window.

-> m ()

Sets a non default parent window for widget.

For Window classes, setting a parentWindow effects whether the window is a toplevel window or can be embedded into other widgets.

For Window classes, this needs to be called before the window is realized.

setRealized

data WidgetSetRealizedMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetRealizedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetRealizedMethodInfo a -> signature -> s

widgetSetRealized

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

realized: True to mark the widget as realized

-> m ()

Marks the widget as being realized. This function must only be called after all GdkWindows for the widget have been created and registered.

This function should only ever be called in a derived widget's “realize” or “unrealize” implementation.

Since: 2.20

setReceivesDefault

data WidgetSetReceivesDefaultMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetReceivesDefaultMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetReceivesDefaultMethodInfo a -> signature -> s

widgetSetReceivesDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

receivesDefault: whether or not widget can be a default widget.

-> m ()

Specifies whether widget will be treated as the default widget within its toplevel when it has the focus, even if another widget is the default.

See widgetGrabDefault for details about the meaning of “default”.

Since: 2.18

setRedrawOnAllocate

data WidgetSetRedrawOnAllocateMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetRedrawOnAllocateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetRedrawOnAllocateMethodInfo a -> signature -> s

widgetSetRedrawOnAllocate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

redrawOnAllocate: if True, the entire widget will be redrawn when it is allocated to a new size. Otherwise, only the new portion of the widget will be redrawn.

-> m ()

Sets whether the entire widget is queued for drawing when its size allocation changes. By default, this setting is True and the entire widget is redrawn on every size change. If your widget leaves the upper left unchanged when made bigger, turning this setting off will improve performance.

Note that for widgets where widgetGetHasWindow is False setting this flag to False turns off all allocation on resizing: the widget will not even redraw if its position changes; this is to allow containers that don’t draw anything to avoid excess invalidations. If you set this flag on a widget with no window that does draw on widget->window, you are responsible for invalidating both the old and new allocation of the widget when the widget is moved and responsible for invalidating regions newly when the widget increases size.

setSensitive

data WidgetSetSensitiveMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetSensitiveMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetSensitiveMethodInfo a -> signature -> s

widgetSetSensitive

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

sensitive: True to make the widget sensitive

-> m ()

Sets the sensitivity of a widget. A widget is sensitive if the user can interact with it. Insensitive widgets are “grayed out” and the user can’t interact with them. Insensitive widgets are known as “inactive”, “disabled”, or “ghosted” in some other toolkits.

setSizeRequest

data WidgetSetSizeRequestMethodInfo

Instances

((~) * signature (Int32 -> Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetSizeRequestMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetSizeRequestMethodInfo a -> signature -> s

widgetSetSizeRequest

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

width: width widget should request, or -1 to unset

-> Int32

height: height widget should request, or -1 to unset

-> m ()

Sets the minimum size of a widget; that is, the widget’s size request will be at least width by height. You can use this function to force a widget to be larger than it normally would be.

In most cases, windowSetDefaultSize is a better choice for toplevel windows than this function; setting the default size will still allow users to shrink the window. Setting the size request will force them to leave the window at least as large as the size request. When dealing with window sizes, windowSetGeometryHints can be a useful function as well.

Note the inherent danger of setting any fixed size - themes, translations into other languages, different fonts, and user action can all change the appropriate size for a given widget. So, it's basically impossible to hardcode a size that will always be correct.

The size request of a widget is the smallest size a widget can accept while still functioning well and drawing itself correctly. However in some strange cases a widget may be allocated less than its requested size, and in many cases a widget may be allocated more space than it requested.

If the size request in a given direction is -1 (unset), then the “natural” size request of the widget will be used instead.

The size request set here does not include any margin from the Widget properties margin-left, margin-right, margin-top, and margin-bottom, but it does include pretty much all other padding or border properties set by any subclass of Widget.

setState

data WidgetSetStateMethodInfo

Instances

((~) * signature (StateType -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetStateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetStateMethodInfo a -> signature -> s

widgetSetState

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> StateType

state: new state for widget

-> m ()

Deprecated: (Since version 3.0)Use widgetSetStateFlags instead.

This function is for use in widget implementations. Sets the state of a widget (insensitive, prelighted, etc.) Usually you should set the state using wrapper functions such as widgetSetSensitive.

setStateFlags

data WidgetSetStateFlagsMethodInfo

Instances

((~) * signature ([StateFlags] -> Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetStateFlagsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetStateFlagsMethodInfo a -> signature -> s

widgetSetStateFlags

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [StateFlags]

flags: State flags to turn on

-> Bool

clear: Whether to clear state before turning on flags

-> m ()

This function is for use in widget implementations. Turns on flag values in the current widget state (insensitive, prelighted, etc.).

This function accepts the values StateFlagsDirLtr and StateFlagsDirRtl but ignores them. If you want to set the widget's direction, use widgetSetDirection.

It is worth mentioning that any other state than StateFlagsInsensitive, will be propagated down to all non-internal children if widget is a Container, while StateFlagsInsensitive itself will be propagated down to all Container children by different means than turning on the state flag down the hierarchy, both widgetGetStateFlags and widgetIsSensitive will make use of these.

Since: 3.0

setStyle

data WidgetSetStyleMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsWidget a, IsStyle b) => MethodInfo * WidgetSetStyleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetStyleMethodInfo a -> signature -> s

widgetSetStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsStyle b)

=> a

widget: a Widget

-> Maybe b

style: a Style, or Nothing to remove the effect of a previous call to widgetSetStyle and go back to the default style

-> m ()

Deprecated: (Since version 3.0)Use StyleContext instead

Used to set the Style for a widget (widget->style). Since GTK 3, this function does nothing, the passed in style is ignored.

setSupportMultidevice

data WidgetSetSupportMultideviceMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetSupportMultideviceMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetSupportMultideviceMethodInfo a -> signature -> s

widgetSetSupportMultidevice

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

supportMultidevice: True to support input from multiple devices.

-> m ()

Enables or disables multiple pointer awareness. If this setting is True, widget will start receiving multiple, per device enter/leave events. Note that if custom GdkWindows are created in Widget::realize, windowSetSupportMultidevice will have to be called manually on them.

Since: 3.0

setTooltipMarkup

data WidgetSetTooltipMarkupMethodInfo

Instances

((~) * signature (Maybe Text -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetTooltipMarkupMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetTooltipMarkupMethodInfo a -> signature -> s

widgetSetTooltipMarkup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Text

markup: the contents of the tooltip for widget, or Nothing

-> m ()

Sets markup as the contents of the tooltip, which is marked up with the [Pango text markup language][PangoMarkupFormat].

This function will take care of setting Widget:has-tooltip to True and of the default handler for the Widget::query-tooltip signal.

See also the Widget:tooltip-markup property and tooltipSetMarkup.

Since: 2.12

setTooltipText

data WidgetSetTooltipTextMethodInfo

Instances

((~) * signature (Maybe Text -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetTooltipTextMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetTooltipTextMethodInfo a -> signature -> s

widgetSetTooltipText

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Text

text: the contents of the tooltip for widget

-> m ()

Sets text as the contents of the tooltip. This function will take care of setting Widget:has-tooltip to True and of the default handler for the Widget::query-tooltip signal.

See also the Widget:tooltip-text property and tooltipSetText.

Since: 2.12

setTooltipWindow

data WidgetSetTooltipWindowMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsWidget a, IsWindow b) => MethodInfo * WidgetSetTooltipWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetTooltipWindowMethodInfo a -> signature -> s

widgetSetTooltipWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWindow b)

=> a

widget: a Widget

-> Maybe b

customWindow: a Window, or Nothing

-> m ()

Replaces the default, usually yellow, window used for displaying tooltips with customWindow. GTK+ will take care of showing and hiding customWindow at the right moment, to behave likewise as the default tooltip window. If customWindow is Nothing, the default tooltip window will be used.

If the custom window should have the default theming it needs to have the name “gtk-tooltip”, see widgetSetName.

Since: 2.12

setValign

data WidgetSetValignMethodInfo

Instances

((~) * signature (Align -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetValignMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetValignMethodInfo a -> signature -> s

widgetSetValign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Align

align: the vertical alignment

-> m ()

Sets the vertical alignment of widget. See the Widget:valign property.

setVexpand

data WidgetSetVexpandMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetVexpandMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetVexpandMethodInfo a -> signature -> s

widgetSetVexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

expand: whether to expand

-> m ()

Sets whether the widget would like any available extra vertical space.

See widgetSetHexpand for more detail.

setVexpandSet

data WidgetSetVexpandSetMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetVexpandSetMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetVexpandSetMethodInfo a -> signature -> s

widgetSetVexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

set: value for vexpand-set property

-> m ()

Sets whether the vexpand flag (see widgetGetVexpand) will be used.

See widgetSetHexpandSet for more detail.

setVisible

data WidgetSetVisibleMethodInfo

Instances

((~) * signature (Bool -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSetVisibleMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetVisibleMethodInfo a -> signature -> s

widgetSetVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

visible: whether the widget should be shown or not

-> m ()

Sets the visibility state of widget. Note that setting this to True doesn’t mean the widget is actually viewable, see widgetGetVisible.

This function simply calls widgetShow or widgetHide but is nicer to use when the visibility of the widget depends on some condition.

Since: 2.18

setVisual

data WidgetSetVisualMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsWidget a, IsVisual b) => MethodInfo * WidgetSetVisualMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetVisualMethodInfo a -> signature -> s

widgetSetVisual

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsVisual b)

=> a

widget: a Widget

-> Maybe b

visual: visual to be used or Nothing to unset a previous one

-> m ()

Sets the visual that should be used for by widget and its children for creating GdkWindows. The visual must be on the same Screen as returned by widgetGetScreen, so handling the Widget::screen-changed signal is necessary.

Setting a new visual will not cause widget to recreate its windows, so you should call this function before widget is realized.

setWindow

data WidgetSetWindowMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWindow b) => MethodInfo * WidgetSetWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSetWindowMethodInfo a -> signature -> s

widgetSetWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWindow b)

=> a

widget: a Widget

-> b

window: a Window

-> m ()

Sets a widget’s window. This function should only be used in a widget’s Widget::realize implementation. The window passed is usually either new window created with windowNew, or the window of its parent widget as returned by widgetGetParentWindow.

Widgets must indicate whether they will create their own Window by calling widgetSetHasWindow. This is usually done in the widget’s init() function.

Note that this function does not add any reference to window.

Since: 2.18

shapeCombineRegion

data WidgetShapeCombineRegionMethodInfo

Instances

((~) * signature (Maybe Region -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetShapeCombineRegionMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetShapeCombineRegionMethodInfo a -> signature -> s

widgetShapeCombineRegion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Region

region: shape to be added, or Nothing to remove an existing shape

-> m ()

Sets a shape for this widget’s GDK window. This allows for transparent windows etc., see windowShapeCombineRegion for more information.

Since: 3.0

show

data WidgetShowMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetShowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetShowMethodInfo a -> signature -> s

widgetShow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Flags a widget to be displayed. Any widget that isn’t shown will not appear on the screen. If you want to show all the widgets in a container, it’s easier to call widgetShowAll on the container, instead of individually showing the widgets.

Remember that you have to show the containers containing a widget, in addition to the widget itself, before it will appear onscreen.

When a toplevel container is shown, it is immediately realized and mapped; other shown widgets are realized and mapped when their toplevel container is realized and mapped.

showAll

data WidgetShowAllMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetShowAllMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetShowAllMethodInfo a -> signature -> s

widgetShowAll

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Recursively shows a widget, and any child widgets (if the widget is a container).

showNow

data WidgetShowNowMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetShowNowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetShowNowMethodInfo a -> signature -> s

widgetShowNow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Shows a widget. If the widget is an unmapped toplevel widget (i.e. a Window that has not yet been shown), enter the main loop and wait for the window to actually be mapped. Be careful; because the main loop is running, anything can happen during this function.

sizeAllocate

data WidgetSizeAllocateMethodInfo

Instances

((~) * signature (Rectangle -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSizeAllocateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSizeAllocateMethodInfo a -> signature -> s

widgetSizeAllocate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Rectangle

allocation: position and size to be allocated to widget

-> m ()

This function is only used by Container subclasses, to assign a size and position to their child widgets.

In this function, the allocation may be adjusted. It will be forced to a 1x1 minimum size, and the adjust_size_allocation virtual method on the child will be used to adjust the allocation. Standard adjustments include removing the widget’s margins, and applying the widget’s Widget:halign and Widget:valign properties.

For baseline support in containers you need to use widgetSizeAllocateWithBaseline instead.

sizeAllocateWithBaseline

data WidgetSizeAllocateWithBaselineMethodInfo

Instances

((~) * signature (Rectangle -> Int32 -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetSizeAllocateWithBaselineMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSizeAllocateWithBaselineMethodInfo a -> signature -> s

widgetSizeAllocateWithBaseline

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Rectangle

allocation: position and size to be allocated to widget

-> Int32

baseline: The baseline of the child, or -1

-> m ()

This function is only used by Container subclasses, to assign a size, position and (optionally) baseline to their child widgets.

In this function, the allocation and baseline may be adjusted. It will be forced to a 1x1 minimum size, and the adjust_size_allocation virtual and adjust_baseline_allocation methods on the child will be used to adjust the allocation and baseline. Standard adjustments include removing the widget's margins, and applying the widget’s Widget:halign and Widget:valign properties.

If the child widget does not have a valign of AlignBaseline the baseline argument is ignored and -1 is used instead.

Since: 3.10

sizeRequest

data WidgetSizeRequestMethodInfo

Instances

((~) * signature (m Requisition), MonadIO m, IsWidget a) => MethodInfo * WidgetSizeRequestMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetSizeRequestMethodInfo a -> signature -> s

widgetSizeRequest

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Requisition

Deprecated: (Since version 3.0)Use widgetGetPreferredSize instead.

This function is typically used when implementing a Container subclass. Obtains the preferred size of a widget. The container uses this information to arrange its child widgets and decide what size allocations to give them with widgetSizeAllocate.

You can also call this function from an application, with some caveats. Most notably, getting a size request requires the widget to be associated with a screen, because font information may be needed. Multihead-aware applications should keep this in mind.

Also remember that the size request is not necessarily the size a widget will actually be allocated.

styleAttach

data WidgetStyleAttachMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetStyleAttachMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetStyleAttachMethodInfo a -> signature -> s

widgetStyleAttach

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Deprecated: (Since version 3.0)This step is unnecessary with StyleContext.

This function attaches the widget’s Style to the widget's Window. It is a replacement for

widget->style = gtk_style_attach (widget->style, widget->window);

and should only ever be called in a derived widget’s “realize” implementation which does not chain up to its parent class' “realize” implementation, because one of the parent classes (finally Widget) would attach the style itself.

Since: 2.20

styleGetProperty

data WidgetStyleGetPropertyMethodInfo

Instances

((~) * signature (Text -> GValue -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetStyleGetPropertyMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetStyleGetPropertyMethodInfo a -> signature -> s

widgetStyleGetProperty

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

propertyName: the name of a style property

-> GValue

value: location to return the property value

-> m ()

Gets the value of a style property of widget.

thawChildNotify

data WidgetThawChildNotifyMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetThawChildNotifyMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetThawChildNotifyMethodInfo a -> signature -> s

widgetThawChildNotify

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Reverts the effect of a previous call to widgetFreezeChildNotify. This causes all queued Widget::child-notify signals on widget to be emitted.

translateCoordinates

data WidgetTranslateCoordinatesMethodInfo

Instances

((~) * signature (b -> Int32 -> Int32 -> m (Bool, Int32, Int32)), MonadIO m, IsWidget a, IsWidget b) => MethodInfo * WidgetTranslateCoordinatesMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetTranslateCoordinatesMethodInfo a -> signature -> s

widgetTranslateCoordinates

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

srcWidget: a Widget

-> b

destWidget: a Widget

-> Int32

srcX: X position relative to srcWidget

-> Int32

srcY: Y position relative to srcWidget

-> m (Bool, Int32, Int32)

Returns: False if either widget was not realized, or there was no common ancestor. In this case, nothing is stored in *destX and *destY. Otherwise True.

Translate coordinates relative to srcWidget’s allocation to coordinates relative to destWidget’s allocations. In order to perform this operation, both widgets must be realized, and must share a common toplevel.

triggerTooltipQuery

data WidgetTriggerTooltipQueryMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetTriggerTooltipQueryMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetTriggerTooltipQueryMethodInfo a -> signature -> s

widgetTriggerTooltipQuery

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Triggers a tooltip query on the display where the toplevel of widget is located. See tooltipTriggerTooltipQuery for more information.

Since: 2.12

unmap

data WidgetUnmapMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetUnmapMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetUnmapMethodInfo a -> signature -> s

widgetUnmap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Causes a widget to be unmapped if it’s currently mapped.

unparent

data WidgetUnparentMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetUnparentMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetUnparentMethodInfo a -> signature -> s

widgetUnparent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Should be called by implementations of the remove method on Container, to dissociate a child from the container.

unrealize

data WidgetUnrealizeMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetUnrealizeMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetUnrealizeMethodInfo a -> signature -> s

widgetUnrealize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only useful in widget implementations. Causes a widget to be unrealized (frees all GDK resources associated with the widget, such as widget->window).

unregisterWindow

data WidgetUnregisterWindowMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsWidget a, IsWindow b) => MethodInfo * WidgetUnregisterWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetUnregisterWindowMethodInfo a -> signature -> s

widgetUnregisterWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWindow b)

=> a

widget: a Widget

-> b

window: a Window

-> m ()

Unregisters a Window from the widget that was previously set up with widgetRegisterWindow. You need to call this when the window is no longer used by the widget, such as when you destroy it.

Since: 3.8

unsetStateFlags

data WidgetUnsetStateFlagsMethodInfo

Instances

((~) * signature ([StateFlags] -> m ()), MonadIO m, IsWidget a) => MethodInfo * WidgetUnsetStateFlagsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy WidgetUnsetStateFlagsMethodInfo a -> signature -> s

widgetUnsetStateFlags

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [StateFlags]

flags: State flags to turn off

-> m ()

This function is for use in widget implementations. Turns off flag values for the current widget state (insensitive, prelighted, etc.). See widgetSetStateFlags.

Since: 3.0

Properties

appPaintable

data WidgetAppPaintablePropertyInfo

Instances

AttrInfo WidgetAppPaintablePropertyInfo

Associated Types

type AttrAllowedOps WidgetAppPaintablePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetAppPaintablePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo :: * -> Constraint

type AttrGetType WidgetAppPaintablePropertyInfo :: *

type AttrLabel WidgetAppPaintablePropertyInfo :: Symbol

type AttrOrigin WidgetAppPaintablePropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo o => Proxy * WidgetAppPaintablePropertyInfo -> o -> IO (AttrGetType WidgetAppPaintablePropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo o, AttrSetTypeConstraint WidgetAppPaintablePropertyInfo b) => Proxy * WidgetAppPaintablePropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo o => Proxy * WidgetAppPaintablePropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo o, AttrSetTypeConstraint WidgetAppPaintablePropertyInfo b) => Proxy * WidgetAppPaintablePropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetAppPaintablePropertyInfo

type AttrOrigin WidgetAppPaintablePropertyInfo = Widget

type AttrLabel WidgetAppPaintablePropertyInfo

type AttrLabel WidgetAppPaintablePropertyInfo = "app-paintable"

type AttrGetType WidgetAppPaintablePropertyInfo

type AttrGetType WidgetAppPaintablePropertyInfo = Bool

type AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo

type AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetAppPaintablePropertyInfo

type AttrSetTypeConstraint WidgetAppPaintablePropertyInfo = * ~ Bool

type AttrAllowedOps WidgetAppPaintablePropertyInfo

type AttrAllowedOps WidgetAppPaintablePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetAppPaintable :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetAppPaintable :: AttrLabelProxy "appPaintable"

canDefault

data WidgetCanDefaultPropertyInfo

Instances

AttrInfo WidgetCanDefaultPropertyInfo

Associated Types

type AttrAllowedOps WidgetCanDefaultPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetCanDefaultPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo :: * -> Constraint

type AttrGetType WidgetCanDefaultPropertyInfo :: *

type AttrLabel WidgetCanDefaultPropertyInfo :: Symbol

type AttrOrigin WidgetCanDefaultPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo o => Proxy * WidgetCanDefaultPropertyInfo -> o -> IO (AttrGetType WidgetCanDefaultPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo o, AttrSetTypeConstraint WidgetCanDefaultPropertyInfo b) => Proxy * WidgetCanDefaultPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo o => Proxy * WidgetCanDefaultPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo o, AttrSetTypeConstraint WidgetCanDefaultPropertyInfo b) => Proxy * WidgetCanDefaultPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetCanDefaultPropertyInfo

type AttrOrigin WidgetCanDefaultPropertyInfo = Widget

type AttrLabel WidgetCanDefaultPropertyInfo

type AttrLabel WidgetCanDefaultPropertyInfo = "can-default"

type AttrGetType WidgetCanDefaultPropertyInfo

type AttrGetType WidgetCanDefaultPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo

type AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetCanDefaultPropertyInfo

type AttrSetTypeConstraint WidgetCanDefaultPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetCanDefaultPropertyInfo

type AttrAllowedOps WidgetCanDefaultPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetCanDefault :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetCanDefault :: AttrLabelProxy "canDefault"

canFocus

data WidgetCanFocusPropertyInfo

Instances

AttrInfo WidgetCanFocusPropertyInfo

Associated Types

type AttrAllowedOps WidgetCanFocusPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetCanFocusPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetCanFocusPropertyInfo :: * -> Constraint

type AttrGetType WidgetCanFocusPropertyInfo :: *

type AttrLabel WidgetCanFocusPropertyInfo :: Symbol

type AttrOrigin WidgetCanFocusPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetCanFocusPropertyInfo o => Proxy * WidgetCanFocusPropertyInfo -> o -> IO (AttrGetType WidgetCanFocusPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetCanFocusPropertyInfo o, AttrSetTypeConstraint WidgetCanFocusPropertyInfo b) => Proxy * WidgetCanFocusPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetCanFocusPropertyInfo o => Proxy * WidgetCanFocusPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetCanFocusPropertyInfo o, AttrSetTypeConstraint WidgetCanFocusPropertyInfo b) => Proxy * WidgetCanFocusPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetCanFocusPropertyInfo

type AttrOrigin WidgetCanFocusPropertyInfo = Widget

type AttrLabel WidgetCanFocusPropertyInfo

type AttrLabel WidgetCanFocusPropertyInfo = "can-focus"

type AttrGetType WidgetCanFocusPropertyInfo

type AttrGetType WidgetCanFocusPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetCanFocusPropertyInfo

type AttrBaseTypeConstraint WidgetCanFocusPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetCanFocusPropertyInfo

type AttrSetTypeConstraint WidgetCanFocusPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetCanFocusPropertyInfo

type AttrAllowedOps WidgetCanFocusPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetCanFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetCanFocus :: AttrLabelProxy "canFocus"

compositeChild

data WidgetCompositeChildPropertyInfo

Instances

AttrInfo WidgetCompositeChildPropertyInfo

Associated Types

type AttrAllowedOps WidgetCompositeChildPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetCompositeChildPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo :: * -> Constraint

type AttrGetType WidgetCompositeChildPropertyInfo :: *

type AttrLabel WidgetCompositeChildPropertyInfo :: Symbol

type AttrOrigin WidgetCompositeChildPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo o => Proxy * WidgetCompositeChildPropertyInfo -> o -> IO (AttrGetType WidgetCompositeChildPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo o, AttrSetTypeConstraint WidgetCompositeChildPropertyInfo b) => Proxy * WidgetCompositeChildPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo o => Proxy * WidgetCompositeChildPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo o, AttrSetTypeConstraint WidgetCompositeChildPropertyInfo b) => Proxy * WidgetCompositeChildPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetCompositeChildPropertyInfo

type AttrOrigin WidgetCompositeChildPropertyInfo = Widget

type AttrLabel WidgetCompositeChildPropertyInfo

type AttrLabel WidgetCompositeChildPropertyInfo = "composite-child"

type AttrGetType WidgetCompositeChildPropertyInfo

type AttrGetType WidgetCompositeChildPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo

type AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetCompositeChildPropertyInfo

type AttrSetTypeConstraint WidgetCompositeChildPropertyInfo = * ~ ()

type AttrAllowedOps WidgetCompositeChildPropertyInfo

type AttrAllowedOps WidgetCompositeChildPropertyInfo = (:) AttrOpTag AttrGet ([] AttrOpTag)

getWidgetCompositeChild :: (MonadIO m, IsWidget o) => o -> m Bool

widgetCompositeChild :: AttrLabelProxy "compositeChild"

doubleBuffered

data WidgetDoubleBufferedPropertyInfo

Instances

AttrInfo WidgetDoubleBufferedPropertyInfo

Associated Types

type AttrAllowedOps WidgetDoubleBufferedPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetDoubleBufferedPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo :: * -> Constraint

type AttrGetType WidgetDoubleBufferedPropertyInfo :: *

type AttrLabel WidgetDoubleBufferedPropertyInfo :: Symbol

type AttrOrigin WidgetDoubleBufferedPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo o => Proxy * WidgetDoubleBufferedPropertyInfo -> o -> IO (AttrGetType WidgetDoubleBufferedPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo o, AttrSetTypeConstraint WidgetDoubleBufferedPropertyInfo b) => Proxy * WidgetDoubleBufferedPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo o => Proxy * WidgetDoubleBufferedPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo o, AttrSetTypeConstraint WidgetDoubleBufferedPropertyInfo b) => Proxy * WidgetDoubleBufferedPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetDoubleBufferedPropertyInfo

type AttrOrigin WidgetDoubleBufferedPropertyInfo = Widget

type AttrLabel WidgetDoubleBufferedPropertyInfo

type AttrLabel WidgetDoubleBufferedPropertyInfo = "double-buffered"

type AttrGetType WidgetDoubleBufferedPropertyInfo

type AttrGetType WidgetDoubleBufferedPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo

type AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetDoubleBufferedPropertyInfo

type AttrSetTypeConstraint WidgetDoubleBufferedPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetDoubleBufferedPropertyInfo

type AttrAllowedOps WidgetDoubleBufferedPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetDoubleBuffered :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetDoubleBuffered :: AttrLabelProxy "doubleBuffered"

events

data WidgetEventsPropertyInfo

Instances

AttrInfo WidgetEventsPropertyInfo

Associated Types

type AttrAllowedOps WidgetEventsPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetEventsPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetEventsPropertyInfo :: * -> Constraint

type AttrGetType WidgetEventsPropertyInfo :: *

type AttrLabel WidgetEventsPropertyInfo :: Symbol

type AttrOrigin WidgetEventsPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetEventsPropertyInfo o => Proxy * WidgetEventsPropertyInfo -> o -> IO (AttrGetType WidgetEventsPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetEventsPropertyInfo o, AttrSetTypeConstraint WidgetEventsPropertyInfo b) => Proxy * WidgetEventsPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetEventsPropertyInfo o => Proxy * WidgetEventsPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetEventsPropertyInfo o, AttrSetTypeConstraint WidgetEventsPropertyInfo b) => Proxy * WidgetEventsPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetEventsPropertyInfo

type AttrOrigin WidgetEventsPropertyInfo = Widget

type AttrLabel WidgetEventsPropertyInfo

type AttrLabel WidgetEventsPropertyInfo = "events"

type AttrGetType WidgetEventsPropertyInfo

type AttrGetType WidgetEventsPropertyInfo = [EventMask]

type AttrBaseTypeConstraint WidgetEventsPropertyInfo

type AttrBaseTypeConstraint WidgetEventsPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetEventsPropertyInfo

type AttrSetTypeConstraint WidgetEventsPropertyInfo = * ~ [EventMask]

type AttrAllowedOps WidgetEventsPropertyInfo

type AttrAllowedOps WidgetEventsPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetEvents :: IsWidget o => [EventMask] -> IO (GValueConstruct o)

getWidgetEvents :: (MonadIO m, IsWidget o) => o -> m [EventMask]

setWidgetEvents :: (MonadIO m, IsWidget o) => o -> [EventMask] -> m ()

widgetEvents :: AttrLabelProxy "events"

expand

data WidgetExpandPropertyInfo

Instances

AttrInfo WidgetExpandPropertyInfo

Associated Types

type AttrAllowedOps WidgetExpandPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetExpandPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetExpandPropertyInfo :: * -> Constraint

type AttrGetType WidgetExpandPropertyInfo :: *

type AttrLabel WidgetExpandPropertyInfo :: Symbol

type AttrOrigin WidgetExpandPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetExpandPropertyInfo o => Proxy * WidgetExpandPropertyInfo -> o -> IO (AttrGetType WidgetExpandPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetExpandPropertyInfo o, AttrSetTypeConstraint WidgetExpandPropertyInfo b) => Proxy * WidgetExpandPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetExpandPropertyInfo o => Proxy * WidgetExpandPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetExpandPropertyInfo o, AttrSetTypeConstraint WidgetExpandPropertyInfo b) => Proxy * WidgetExpandPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetExpandPropertyInfo

type AttrOrigin WidgetExpandPropertyInfo = Widget

type AttrLabel WidgetExpandPropertyInfo

type AttrLabel WidgetExpandPropertyInfo = "expand"

type AttrGetType WidgetExpandPropertyInfo

type AttrGetType WidgetExpandPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetExpandPropertyInfo

type AttrBaseTypeConstraint WidgetExpandPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetExpandPropertyInfo

type AttrSetTypeConstraint WidgetExpandPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetExpandPropertyInfo

type AttrAllowedOps WidgetExpandPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetExpand :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetExpand :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetExpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetExpand :: AttrLabelProxy "expand"

focusOnClick

data WidgetFocusOnClickPropertyInfo

Instances

AttrInfo WidgetFocusOnClickPropertyInfo

Associated Types

type AttrAllowedOps WidgetFocusOnClickPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetFocusOnClickPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo :: * -> Constraint

type AttrGetType WidgetFocusOnClickPropertyInfo :: *

type AttrLabel WidgetFocusOnClickPropertyInfo :: Symbol

type AttrOrigin WidgetFocusOnClickPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo o => Proxy * WidgetFocusOnClickPropertyInfo -> o -> IO (AttrGetType WidgetFocusOnClickPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo o, AttrSetTypeConstraint WidgetFocusOnClickPropertyInfo b) => Proxy * WidgetFocusOnClickPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo o => Proxy * WidgetFocusOnClickPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo o, AttrSetTypeConstraint WidgetFocusOnClickPropertyInfo b) => Proxy * WidgetFocusOnClickPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetFocusOnClickPropertyInfo

type AttrOrigin WidgetFocusOnClickPropertyInfo = Widget

type AttrLabel WidgetFocusOnClickPropertyInfo

type AttrLabel WidgetFocusOnClickPropertyInfo = "focus-on-click"

type AttrGetType WidgetFocusOnClickPropertyInfo

type AttrGetType WidgetFocusOnClickPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo

type AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetFocusOnClickPropertyInfo

type AttrSetTypeConstraint WidgetFocusOnClickPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetFocusOnClickPropertyInfo

type AttrAllowedOps WidgetFocusOnClickPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetFocusOnClick :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetFocusOnClick :: AttrLabelProxy "focusOnClick"

halign

data WidgetHalignPropertyInfo

Instances

AttrInfo WidgetHalignPropertyInfo

Associated Types

type AttrAllowedOps WidgetHalignPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetHalignPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetHalignPropertyInfo :: * -> Constraint

type AttrGetType WidgetHalignPropertyInfo :: *

type AttrLabel WidgetHalignPropertyInfo :: Symbol

type AttrOrigin WidgetHalignPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetHalignPropertyInfo o => Proxy * WidgetHalignPropertyInfo -> o -> IO (AttrGetType WidgetHalignPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetHalignPropertyInfo o, AttrSetTypeConstraint WidgetHalignPropertyInfo b) => Proxy * WidgetHalignPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetHalignPropertyInfo o => Proxy * WidgetHalignPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetHalignPropertyInfo o, AttrSetTypeConstraint WidgetHalignPropertyInfo b) => Proxy * WidgetHalignPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetHalignPropertyInfo

type AttrOrigin WidgetHalignPropertyInfo = Widget

type AttrLabel WidgetHalignPropertyInfo

type AttrLabel WidgetHalignPropertyInfo = "halign"

type AttrGetType WidgetHalignPropertyInfo

type AttrGetType WidgetHalignPropertyInfo = Align

type AttrBaseTypeConstraint WidgetHalignPropertyInfo

type AttrBaseTypeConstraint WidgetHalignPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetHalignPropertyInfo

type AttrSetTypeConstraint WidgetHalignPropertyInfo = * ~ Align

type AttrAllowedOps WidgetHalignPropertyInfo

type AttrAllowedOps WidgetHalignPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetHalign :: IsWidget o => Align -> IO (GValueConstruct o)

getWidgetHalign :: (MonadIO m, IsWidget o) => o -> m Align

setWidgetHalign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

widgetHalign :: AttrLabelProxy "halign"

hasDefault

data WidgetHasDefaultPropertyInfo

Instances

AttrInfo WidgetHasDefaultPropertyInfo

Associated Types

type AttrAllowedOps WidgetHasDefaultPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetHasDefaultPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo :: * -> Constraint

type AttrGetType WidgetHasDefaultPropertyInfo :: *

type AttrLabel WidgetHasDefaultPropertyInfo :: Symbol

type AttrOrigin WidgetHasDefaultPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo o => Proxy * WidgetHasDefaultPropertyInfo -> o -> IO (AttrGetType WidgetHasDefaultPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo o, AttrSetTypeConstraint WidgetHasDefaultPropertyInfo b) => Proxy * WidgetHasDefaultPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo o => Proxy * WidgetHasDefaultPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo o, AttrSetTypeConstraint WidgetHasDefaultPropertyInfo b) => Proxy * WidgetHasDefaultPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetHasDefaultPropertyInfo

type AttrOrigin WidgetHasDefaultPropertyInfo = Widget

type AttrLabel WidgetHasDefaultPropertyInfo

type AttrLabel WidgetHasDefaultPropertyInfo = "has-default"

type AttrGetType WidgetHasDefaultPropertyInfo

type AttrGetType WidgetHasDefaultPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo

type AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetHasDefaultPropertyInfo

type AttrSetTypeConstraint WidgetHasDefaultPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetHasDefaultPropertyInfo

type AttrAllowedOps WidgetHasDefaultPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetHasDefault :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

hasFocus

data WidgetHasFocusPropertyInfo

Instances

AttrInfo WidgetHasFocusPropertyInfo

Associated Types

type AttrAllowedOps WidgetHasFocusPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetHasFocusPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetHasFocusPropertyInfo :: * -> Constraint

type AttrGetType WidgetHasFocusPropertyInfo :: *

type AttrLabel WidgetHasFocusPropertyInfo :: Symbol

type AttrOrigin WidgetHasFocusPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetHasFocusPropertyInfo o => Proxy * WidgetHasFocusPropertyInfo -> o -> IO (AttrGetType WidgetHasFocusPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetHasFocusPropertyInfo o, AttrSetTypeConstraint WidgetHasFocusPropertyInfo b) => Proxy * WidgetHasFocusPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetHasFocusPropertyInfo o => Proxy * WidgetHasFocusPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetHasFocusPropertyInfo o, AttrSetTypeConstraint WidgetHasFocusPropertyInfo b) => Proxy * WidgetHasFocusPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetHasFocusPropertyInfo

type AttrOrigin WidgetHasFocusPropertyInfo = Widget

type AttrLabel WidgetHasFocusPropertyInfo

type AttrLabel WidgetHasFocusPropertyInfo = "has-focus"

type AttrGetType WidgetHasFocusPropertyInfo

type AttrGetType WidgetHasFocusPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetHasFocusPropertyInfo

type AttrBaseTypeConstraint WidgetHasFocusPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetHasFocusPropertyInfo

type AttrSetTypeConstraint WidgetHasFocusPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetHasFocusPropertyInfo

type AttrAllowedOps WidgetHasFocusPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetHasFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

hasTooltip

data WidgetHasTooltipPropertyInfo

Instances

AttrInfo WidgetHasTooltipPropertyInfo

Associated Types

type AttrAllowedOps WidgetHasTooltipPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetHasTooltipPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo :: * -> Constraint

type AttrGetType WidgetHasTooltipPropertyInfo :: *

type AttrLabel WidgetHasTooltipPropertyInfo :: Symbol

type AttrOrigin WidgetHasTooltipPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo o => Proxy * WidgetHasTooltipPropertyInfo -> o -> IO (AttrGetType WidgetHasTooltipPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo o, AttrSetTypeConstraint WidgetHasTooltipPropertyInfo b) => Proxy * WidgetHasTooltipPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo o => Proxy * WidgetHasTooltipPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo o, AttrSetTypeConstraint WidgetHasTooltipPropertyInfo b) => Proxy * WidgetHasTooltipPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetHasTooltipPropertyInfo

type AttrOrigin WidgetHasTooltipPropertyInfo = Widget

type AttrLabel WidgetHasTooltipPropertyInfo

type AttrLabel WidgetHasTooltipPropertyInfo = "has-tooltip"

type AttrGetType WidgetHasTooltipPropertyInfo

type AttrGetType WidgetHasTooltipPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo

type AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetHasTooltipPropertyInfo

type AttrSetTypeConstraint WidgetHasTooltipPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetHasTooltipPropertyInfo

type AttrAllowedOps WidgetHasTooltipPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetHasTooltip :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetHasTooltip :: AttrLabelProxy "hasTooltip"

heightRequest

data WidgetHeightRequestPropertyInfo

Instances

AttrInfo WidgetHeightRequestPropertyInfo

Associated Types

type AttrAllowedOps WidgetHeightRequestPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetHeightRequestPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo :: * -> Constraint

type AttrGetType WidgetHeightRequestPropertyInfo :: *

type AttrLabel WidgetHeightRequestPropertyInfo :: Symbol

type AttrOrigin WidgetHeightRequestPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo o => Proxy * WidgetHeightRequestPropertyInfo -> o -> IO (AttrGetType WidgetHeightRequestPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo o, AttrSetTypeConstraint WidgetHeightRequestPropertyInfo b) => Proxy * WidgetHeightRequestPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo o => Proxy * WidgetHeightRequestPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo o, AttrSetTypeConstraint WidgetHeightRequestPropertyInfo b) => Proxy * WidgetHeightRequestPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetHeightRequestPropertyInfo

type AttrOrigin WidgetHeightRequestPropertyInfo = Widget

type AttrLabel WidgetHeightRequestPropertyInfo

type AttrLabel WidgetHeightRequestPropertyInfo = "height-request"

type AttrGetType WidgetHeightRequestPropertyInfo

type AttrGetType WidgetHeightRequestPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo

type AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetHeightRequestPropertyInfo

type AttrSetTypeConstraint WidgetHeightRequestPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetHeightRequestPropertyInfo

type AttrAllowedOps WidgetHeightRequestPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetHeightRequest :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetHeightRequest :: AttrLabelProxy "heightRequest"

hexpand

data WidgetHexpandPropertyInfo

Instances

AttrInfo WidgetHexpandPropertyInfo

Associated Types

type AttrAllowedOps WidgetHexpandPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetHexpandPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetHexpandPropertyInfo :: * -> Constraint

type AttrGetType WidgetHexpandPropertyInfo :: *

type AttrLabel WidgetHexpandPropertyInfo :: Symbol

type AttrOrigin WidgetHexpandPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetHexpandPropertyInfo o => Proxy * WidgetHexpandPropertyInfo -> o -> IO (AttrGetType WidgetHexpandPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetHexpandPropertyInfo o, AttrSetTypeConstraint WidgetHexpandPropertyInfo b) => Proxy * WidgetHexpandPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetHexpandPropertyInfo o => Proxy * WidgetHexpandPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetHexpandPropertyInfo o, AttrSetTypeConstraint WidgetHexpandPropertyInfo b) => Proxy * WidgetHexpandPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetHexpandPropertyInfo

type AttrOrigin WidgetHexpandPropertyInfo = Widget

type AttrLabel WidgetHexpandPropertyInfo

type AttrLabel WidgetHexpandPropertyInfo = "hexpand"

type AttrGetType WidgetHexpandPropertyInfo

type AttrGetType WidgetHexpandPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetHexpandPropertyInfo

type AttrBaseTypeConstraint WidgetHexpandPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetHexpandPropertyInfo

type AttrSetTypeConstraint WidgetHexpandPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetHexpandPropertyInfo

type AttrAllowedOps WidgetHexpandPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetHexpand :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetHexpand :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetHexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetHexpand :: AttrLabelProxy "hexpand"

hexpandSet

data WidgetHexpandSetPropertyInfo

Instances

AttrInfo WidgetHexpandSetPropertyInfo

Associated Types

type AttrAllowedOps WidgetHexpandSetPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetHexpandSetPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo :: * -> Constraint

type AttrGetType WidgetHexpandSetPropertyInfo :: *

type AttrLabel WidgetHexpandSetPropertyInfo :: Symbol

type AttrOrigin WidgetHexpandSetPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo o => Proxy * WidgetHexpandSetPropertyInfo -> o -> IO (AttrGetType WidgetHexpandSetPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo o, AttrSetTypeConstraint WidgetHexpandSetPropertyInfo b) => Proxy * WidgetHexpandSetPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo o => Proxy * WidgetHexpandSetPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo o, AttrSetTypeConstraint WidgetHexpandSetPropertyInfo b) => Proxy * WidgetHexpandSetPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetHexpandSetPropertyInfo

type AttrOrigin WidgetHexpandSetPropertyInfo = Widget

type AttrLabel WidgetHexpandSetPropertyInfo

type AttrLabel WidgetHexpandSetPropertyInfo = "hexpand-set"

type AttrGetType WidgetHexpandSetPropertyInfo

type AttrGetType WidgetHexpandSetPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo

type AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetHexpandSetPropertyInfo

type AttrSetTypeConstraint WidgetHexpandSetPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetHexpandSetPropertyInfo

type AttrAllowedOps WidgetHexpandSetPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetHexpandSet :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetHexpandSet :: AttrLabelProxy "hexpandSet"

isFocus

data WidgetIsFocusPropertyInfo

Instances

AttrInfo WidgetIsFocusPropertyInfo

Associated Types

type AttrAllowedOps WidgetIsFocusPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetIsFocusPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetIsFocusPropertyInfo :: * -> Constraint

type AttrGetType WidgetIsFocusPropertyInfo :: *

type AttrLabel WidgetIsFocusPropertyInfo :: Symbol

type AttrOrigin WidgetIsFocusPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetIsFocusPropertyInfo o => Proxy * WidgetIsFocusPropertyInfo -> o -> IO (AttrGetType WidgetIsFocusPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetIsFocusPropertyInfo o, AttrSetTypeConstraint WidgetIsFocusPropertyInfo b) => Proxy * WidgetIsFocusPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetIsFocusPropertyInfo o => Proxy * WidgetIsFocusPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetIsFocusPropertyInfo o, AttrSetTypeConstraint WidgetIsFocusPropertyInfo b) => Proxy * WidgetIsFocusPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetIsFocusPropertyInfo

type AttrOrigin WidgetIsFocusPropertyInfo = Widget

type AttrLabel WidgetIsFocusPropertyInfo

type AttrLabel WidgetIsFocusPropertyInfo = "is-focus"

type AttrGetType WidgetIsFocusPropertyInfo

type AttrGetType WidgetIsFocusPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetIsFocusPropertyInfo

type AttrBaseTypeConstraint WidgetIsFocusPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetIsFocusPropertyInfo

type AttrSetTypeConstraint WidgetIsFocusPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetIsFocusPropertyInfo

type AttrAllowedOps WidgetIsFocusPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetIsFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

margin

data WidgetMarginPropertyInfo

Instances

AttrInfo WidgetMarginPropertyInfo

Associated Types

type AttrAllowedOps WidgetMarginPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetMarginPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetMarginPropertyInfo :: * -> Constraint

type AttrGetType WidgetMarginPropertyInfo :: *

type AttrLabel WidgetMarginPropertyInfo :: Symbol

type AttrOrigin WidgetMarginPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetMarginPropertyInfo o => Proxy * WidgetMarginPropertyInfo -> o -> IO (AttrGetType WidgetMarginPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetMarginPropertyInfo o, AttrSetTypeConstraint WidgetMarginPropertyInfo b) => Proxy * WidgetMarginPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetMarginPropertyInfo o => Proxy * WidgetMarginPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetMarginPropertyInfo o, AttrSetTypeConstraint WidgetMarginPropertyInfo b) => Proxy * WidgetMarginPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetMarginPropertyInfo

type AttrOrigin WidgetMarginPropertyInfo = Widget

type AttrLabel WidgetMarginPropertyInfo

type AttrLabel WidgetMarginPropertyInfo = "margin"

type AttrGetType WidgetMarginPropertyInfo

type AttrGetType WidgetMarginPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetMarginPropertyInfo

type AttrBaseTypeConstraint WidgetMarginPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetMarginPropertyInfo

type AttrSetTypeConstraint WidgetMarginPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetMarginPropertyInfo

type AttrAllowedOps WidgetMarginPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetMargin :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetMargin :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetMargin :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetMargin :: AttrLabelProxy "margin"

marginBottom

data WidgetMarginBottomPropertyInfo

Instances

AttrInfo WidgetMarginBottomPropertyInfo

Associated Types

type AttrAllowedOps WidgetMarginBottomPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetMarginBottomPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo :: * -> Constraint

type AttrGetType WidgetMarginBottomPropertyInfo :: *

type AttrLabel WidgetMarginBottomPropertyInfo :: Symbol

type AttrOrigin WidgetMarginBottomPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo o => Proxy * WidgetMarginBottomPropertyInfo -> o -> IO (AttrGetType WidgetMarginBottomPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo o, AttrSetTypeConstraint WidgetMarginBottomPropertyInfo b) => Proxy * WidgetMarginBottomPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo o => Proxy * WidgetMarginBottomPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo o, AttrSetTypeConstraint WidgetMarginBottomPropertyInfo b) => Proxy * WidgetMarginBottomPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetMarginBottomPropertyInfo

type AttrOrigin WidgetMarginBottomPropertyInfo = Widget

type AttrLabel WidgetMarginBottomPropertyInfo

type AttrLabel WidgetMarginBottomPropertyInfo = "margin-bottom"

type AttrGetType WidgetMarginBottomPropertyInfo

type AttrGetType WidgetMarginBottomPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo

type AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetMarginBottomPropertyInfo

type AttrSetTypeConstraint WidgetMarginBottomPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetMarginBottomPropertyInfo

type AttrAllowedOps WidgetMarginBottomPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetMarginBottom :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetMarginBottom :: AttrLabelProxy "marginBottom"

marginEnd

data WidgetMarginEndPropertyInfo

Instances

AttrInfo WidgetMarginEndPropertyInfo

Associated Types

type AttrAllowedOps WidgetMarginEndPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetMarginEndPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetMarginEndPropertyInfo :: * -> Constraint

type AttrGetType WidgetMarginEndPropertyInfo :: *

type AttrLabel WidgetMarginEndPropertyInfo :: Symbol

type AttrOrigin WidgetMarginEndPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetMarginEndPropertyInfo o => Proxy * WidgetMarginEndPropertyInfo -> o -> IO (AttrGetType WidgetMarginEndPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetMarginEndPropertyInfo o, AttrSetTypeConstraint WidgetMarginEndPropertyInfo b) => Proxy * WidgetMarginEndPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetMarginEndPropertyInfo o => Proxy * WidgetMarginEndPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetMarginEndPropertyInfo o, AttrSetTypeConstraint WidgetMarginEndPropertyInfo b) => Proxy * WidgetMarginEndPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetMarginEndPropertyInfo

type AttrOrigin WidgetMarginEndPropertyInfo = Widget

type AttrLabel WidgetMarginEndPropertyInfo

type AttrLabel WidgetMarginEndPropertyInfo = "margin-end"

type AttrGetType WidgetMarginEndPropertyInfo

type AttrGetType WidgetMarginEndPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetMarginEndPropertyInfo

type AttrBaseTypeConstraint WidgetMarginEndPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetMarginEndPropertyInfo

type AttrSetTypeConstraint WidgetMarginEndPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetMarginEndPropertyInfo

type AttrAllowedOps WidgetMarginEndPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetMarginEnd :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetMarginEnd :: AttrLabelProxy "marginEnd"

marginLeft

data WidgetMarginLeftPropertyInfo

Instances

AttrInfo WidgetMarginLeftPropertyInfo

Associated Types

type AttrAllowedOps WidgetMarginLeftPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetMarginLeftPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo :: * -> Constraint

type AttrGetType WidgetMarginLeftPropertyInfo :: *

type AttrLabel WidgetMarginLeftPropertyInfo :: Symbol

type AttrOrigin WidgetMarginLeftPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo o => Proxy * WidgetMarginLeftPropertyInfo -> o -> IO (AttrGetType WidgetMarginLeftPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo o, AttrSetTypeConstraint WidgetMarginLeftPropertyInfo b) => Proxy * WidgetMarginLeftPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo o => Proxy * WidgetMarginLeftPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo o, AttrSetTypeConstraint WidgetMarginLeftPropertyInfo b) => Proxy * WidgetMarginLeftPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetMarginLeftPropertyInfo

type AttrOrigin WidgetMarginLeftPropertyInfo = Widget

type AttrLabel WidgetMarginLeftPropertyInfo

type AttrLabel WidgetMarginLeftPropertyInfo = "margin-left"

type AttrGetType WidgetMarginLeftPropertyInfo

type AttrGetType WidgetMarginLeftPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo

type AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetMarginLeftPropertyInfo

type AttrSetTypeConstraint WidgetMarginLeftPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetMarginLeftPropertyInfo

type AttrAllowedOps WidgetMarginLeftPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetMarginLeft :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetMarginLeft :: AttrLabelProxy "marginLeft"

marginRight

data WidgetMarginRightPropertyInfo

Instances

AttrInfo WidgetMarginRightPropertyInfo

Associated Types

type AttrAllowedOps WidgetMarginRightPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetMarginRightPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetMarginRightPropertyInfo :: * -> Constraint

type AttrGetType WidgetMarginRightPropertyInfo :: *

type AttrLabel WidgetMarginRightPropertyInfo :: Symbol

type AttrOrigin WidgetMarginRightPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetMarginRightPropertyInfo o => Proxy * WidgetMarginRightPropertyInfo -> o -> IO (AttrGetType WidgetMarginRightPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetMarginRightPropertyInfo o, AttrSetTypeConstraint WidgetMarginRightPropertyInfo b) => Proxy * WidgetMarginRightPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetMarginRightPropertyInfo o => Proxy * WidgetMarginRightPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetMarginRightPropertyInfo o, AttrSetTypeConstraint WidgetMarginRightPropertyInfo b) => Proxy * WidgetMarginRightPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetMarginRightPropertyInfo

type AttrOrigin WidgetMarginRightPropertyInfo = Widget

type AttrLabel WidgetMarginRightPropertyInfo

type AttrLabel WidgetMarginRightPropertyInfo = "margin-right"

type AttrGetType WidgetMarginRightPropertyInfo

type AttrGetType WidgetMarginRightPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetMarginRightPropertyInfo

type AttrBaseTypeConstraint WidgetMarginRightPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetMarginRightPropertyInfo

type AttrSetTypeConstraint WidgetMarginRightPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetMarginRightPropertyInfo

type AttrAllowedOps WidgetMarginRightPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetMarginRight :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetMarginRight :: AttrLabelProxy "marginRight"

marginStart

data WidgetMarginStartPropertyInfo

Instances

AttrInfo WidgetMarginStartPropertyInfo

Associated Types

type AttrAllowedOps WidgetMarginStartPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetMarginStartPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetMarginStartPropertyInfo :: * -> Constraint

type AttrGetType WidgetMarginStartPropertyInfo :: *

type AttrLabel WidgetMarginStartPropertyInfo :: Symbol

type AttrOrigin WidgetMarginStartPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetMarginStartPropertyInfo o => Proxy * WidgetMarginStartPropertyInfo -> o -> IO (AttrGetType WidgetMarginStartPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetMarginStartPropertyInfo o, AttrSetTypeConstraint WidgetMarginStartPropertyInfo b) => Proxy * WidgetMarginStartPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetMarginStartPropertyInfo o => Proxy * WidgetMarginStartPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetMarginStartPropertyInfo o, AttrSetTypeConstraint WidgetMarginStartPropertyInfo b) => Proxy * WidgetMarginStartPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetMarginStartPropertyInfo

type AttrOrigin WidgetMarginStartPropertyInfo = Widget

type AttrLabel WidgetMarginStartPropertyInfo

type AttrLabel WidgetMarginStartPropertyInfo = "margin-start"

type AttrGetType WidgetMarginStartPropertyInfo

type AttrGetType WidgetMarginStartPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetMarginStartPropertyInfo

type AttrBaseTypeConstraint WidgetMarginStartPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetMarginStartPropertyInfo

type AttrSetTypeConstraint WidgetMarginStartPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetMarginStartPropertyInfo

type AttrAllowedOps WidgetMarginStartPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetMarginStart :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetMarginStart :: AttrLabelProxy "marginStart"

marginTop

data WidgetMarginTopPropertyInfo

Instances

AttrInfo WidgetMarginTopPropertyInfo

Associated Types

type AttrAllowedOps WidgetMarginTopPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetMarginTopPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetMarginTopPropertyInfo :: * -> Constraint

type AttrGetType WidgetMarginTopPropertyInfo :: *

type AttrLabel WidgetMarginTopPropertyInfo :: Symbol

type AttrOrigin WidgetMarginTopPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetMarginTopPropertyInfo o => Proxy * WidgetMarginTopPropertyInfo -> o -> IO (AttrGetType WidgetMarginTopPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetMarginTopPropertyInfo o, AttrSetTypeConstraint WidgetMarginTopPropertyInfo b) => Proxy * WidgetMarginTopPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetMarginTopPropertyInfo o => Proxy * WidgetMarginTopPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetMarginTopPropertyInfo o, AttrSetTypeConstraint WidgetMarginTopPropertyInfo b) => Proxy * WidgetMarginTopPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetMarginTopPropertyInfo

type AttrOrigin WidgetMarginTopPropertyInfo = Widget

type AttrLabel WidgetMarginTopPropertyInfo

type AttrLabel WidgetMarginTopPropertyInfo = "margin-top"

type AttrGetType WidgetMarginTopPropertyInfo

type AttrGetType WidgetMarginTopPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetMarginTopPropertyInfo

type AttrBaseTypeConstraint WidgetMarginTopPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetMarginTopPropertyInfo

type AttrSetTypeConstraint WidgetMarginTopPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetMarginTopPropertyInfo

type AttrAllowedOps WidgetMarginTopPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetMarginTop :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetMarginTop :: AttrLabelProxy "marginTop"

name

data WidgetNamePropertyInfo

Instances

AttrInfo WidgetNamePropertyInfo

Associated Types

type AttrAllowedOps WidgetNamePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetNamePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetNamePropertyInfo :: * -> Constraint

type AttrGetType WidgetNamePropertyInfo :: *

type AttrLabel WidgetNamePropertyInfo :: Symbol

type AttrOrigin WidgetNamePropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetNamePropertyInfo o => Proxy * WidgetNamePropertyInfo -> o -> IO (AttrGetType WidgetNamePropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetNamePropertyInfo o, AttrSetTypeConstraint WidgetNamePropertyInfo b) => Proxy * WidgetNamePropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetNamePropertyInfo o => Proxy * WidgetNamePropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetNamePropertyInfo o, AttrSetTypeConstraint WidgetNamePropertyInfo b) => Proxy * WidgetNamePropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetNamePropertyInfo

type AttrOrigin WidgetNamePropertyInfo = Widget

type AttrLabel WidgetNamePropertyInfo

type AttrLabel WidgetNamePropertyInfo = "name"

type AttrGetType WidgetNamePropertyInfo

type AttrGetType WidgetNamePropertyInfo = Text

type AttrBaseTypeConstraint WidgetNamePropertyInfo

type AttrBaseTypeConstraint WidgetNamePropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetNamePropertyInfo

type AttrSetTypeConstraint WidgetNamePropertyInfo = * ~ Text

type AttrAllowedOps WidgetNamePropertyInfo

type AttrAllowedOps WidgetNamePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetName :: IsWidget o => Text -> IO (GValueConstruct o)

getWidgetName :: (MonadIO m, IsWidget o) => o -> m Text

setWidgetName :: (MonadIO m, IsWidget o) => o -> Text -> m ()

widgetName :: AttrLabelProxy "name"

noShowAll

data WidgetNoShowAllPropertyInfo

Instances

AttrInfo WidgetNoShowAllPropertyInfo

Associated Types

type AttrAllowedOps WidgetNoShowAllPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetNoShowAllPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo :: * -> Constraint

type AttrGetType WidgetNoShowAllPropertyInfo :: *

type AttrLabel WidgetNoShowAllPropertyInfo :: Symbol

type AttrOrigin WidgetNoShowAllPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo o => Proxy * WidgetNoShowAllPropertyInfo -> o -> IO (AttrGetType WidgetNoShowAllPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo o, AttrSetTypeConstraint WidgetNoShowAllPropertyInfo b) => Proxy * WidgetNoShowAllPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo o => Proxy * WidgetNoShowAllPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo o, AttrSetTypeConstraint WidgetNoShowAllPropertyInfo b) => Proxy * WidgetNoShowAllPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetNoShowAllPropertyInfo

type AttrOrigin WidgetNoShowAllPropertyInfo = Widget

type AttrLabel WidgetNoShowAllPropertyInfo

type AttrLabel WidgetNoShowAllPropertyInfo = "no-show-all"

type AttrGetType WidgetNoShowAllPropertyInfo

type AttrGetType WidgetNoShowAllPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo

type AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetNoShowAllPropertyInfo

type AttrSetTypeConstraint WidgetNoShowAllPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetNoShowAllPropertyInfo

type AttrAllowedOps WidgetNoShowAllPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetNoShowAll :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetNoShowAll :: AttrLabelProxy "noShowAll"

opacity

data WidgetOpacityPropertyInfo

Instances

AttrInfo WidgetOpacityPropertyInfo

Associated Types

type AttrAllowedOps WidgetOpacityPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetOpacityPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetOpacityPropertyInfo :: * -> Constraint

type AttrGetType WidgetOpacityPropertyInfo :: *

type AttrLabel WidgetOpacityPropertyInfo :: Symbol

type AttrOrigin WidgetOpacityPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetOpacityPropertyInfo o => Proxy * WidgetOpacityPropertyInfo -> o -> IO (AttrGetType WidgetOpacityPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetOpacityPropertyInfo o, AttrSetTypeConstraint WidgetOpacityPropertyInfo b) => Proxy * WidgetOpacityPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetOpacityPropertyInfo o => Proxy * WidgetOpacityPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetOpacityPropertyInfo o, AttrSetTypeConstraint WidgetOpacityPropertyInfo b) => Proxy * WidgetOpacityPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetOpacityPropertyInfo

type AttrOrigin WidgetOpacityPropertyInfo = Widget

type AttrLabel WidgetOpacityPropertyInfo

type AttrLabel WidgetOpacityPropertyInfo = "opacity"

type AttrGetType WidgetOpacityPropertyInfo

type AttrGetType WidgetOpacityPropertyInfo = Double

type AttrBaseTypeConstraint WidgetOpacityPropertyInfo

type AttrBaseTypeConstraint WidgetOpacityPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetOpacityPropertyInfo

type AttrSetTypeConstraint WidgetOpacityPropertyInfo = * ~ Double

type AttrAllowedOps WidgetOpacityPropertyInfo

type AttrAllowedOps WidgetOpacityPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetOpacity :: IsWidget o => Double -> IO (GValueConstruct o)

getWidgetOpacity :: (MonadIO m, IsWidget o) => o -> m Double

setWidgetOpacity :: (MonadIO m, IsWidget o) => o -> Double -> m ()

widgetOpacity :: AttrLabelProxy "opacity"

parent

data WidgetParentPropertyInfo

Instances

AttrInfo WidgetParentPropertyInfo

Associated Types

type AttrAllowedOps WidgetParentPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetParentPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetParentPropertyInfo :: * -> Constraint

type AttrGetType WidgetParentPropertyInfo :: *

type AttrLabel WidgetParentPropertyInfo :: Symbol

type AttrOrigin WidgetParentPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetParentPropertyInfo o => Proxy * WidgetParentPropertyInfo -> o -> IO (AttrGetType WidgetParentPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetParentPropertyInfo o, AttrSetTypeConstraint WidgetParentPropertyInfo b) => Proxy * WidgetParentPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetParentPropertyInfo o => Proxy * WidgetParentPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetParentPropertyInfo o, AttrSetTypeConstraint WidgetParentPropertyInfo b) => Proxy * WidgetParentPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetParentPropertyInfo

type AttrOrigin WidgetParentPropertyInfo = Widget

type AttrLabel WidgetParentPropertyInfo

type AttrLabel WidgetParentPropertyInfo = "parent"

type AttrGetType WidgetParentPropertyInfo

type AttrGetType WidgetParentPropertyInfo = Maybe Container

type AttrBaseTypeConstraint WidgetParentPropertyInfo

type AttrBaseTypeConstraint WidgetParentPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetParentPropertyInfo

type AttrSetTypeConstraint WidgetParentPropertyInfo = IsContainer

type AttrAllowedOps WidgetParentPropertyInfo

type AttrAllowedOps WidgetParentPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearWidgetParent :: (MonadIO m, IsWidget o) => o -> m ()

constructWidgetParent :: (IsWidget o, IsContainer a) => a -> IO (GValueConstruct o)

getWidgetParent :: (MonadIO m, IsWidget o) => o -> m (Maybe Container)

setWidgetParent :: (MonadIO m, IsWidget o, IsContainer a) => o -> a -> m ()

widgetParent :: AttrLabelProxy "parent"

receivesDefault

data WidgetReceivesDefaultPropertyInfo

Instances

AttrInfo WidgetReceivesDefaultPropertyInfo

Associated Types

type AttrAllowedOps WidgetReceivesDefaultPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetReceivesDefaultPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo :: * -> Constraint

type AttrGetType WidgetReceivesDefaultPropertyInfo :: *

type AttrLabel WidgetReceivesDefaultPropertyInfo :: Symbol

type AttrOrigin WidgetReceivesDefaultPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo o => Proxy * WidgetReceivesDefaultPropertyInfo -> o -> IO (AttrGetType WidgetReceivesDefaultPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo o, AttrSetTypeConstraint WidgetReceivesDefaultPropertyInfo b) => Proxy * WidgetReceivesDefaultPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo o => Proxy * WidgetReceivesDefaultPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo o, AttrSetTypeConstraint WidgetReceivesDefaultPropertyInfo b) => Proxy * WidgetReceivesDefaultPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetReceivesDefaultPropertyInfo

type AttrOrigin WidgetReceivesDefaultPropertyInfo = Widget

type AttrLabel WidgetReceivesDefaultPropertyInfo

type AttrLabel WidgetReceivesDefaultPropertyInfo = "receives-default"

type AttrGetType WidgetReceivesDefaultPropertyInfo

type AttrGetType WidgetReceivesDefaultPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo

type AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetReceivesDefaultPropertyInfo

type AttrSetTypeConstraint WidgetReceivesDefaultPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetReceivesDefaultPropertyInfo

type AttrAllowedOps WidgetReceivesDefaultPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetReceivesDefault :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetReceivesDefault :: AttrLabelProxy "receivesDefault"

scaleFactor

data WidgetScaleFactorPropertyInfo

Instances

AttrInfo WidgetScaleFactorPropertyInfo

Associated Types

type AttrAllowedOps WidgetScaleFactorPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetScaleFactorPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo :: * -> Constraint

type AttrGetType WidgetScaleFactorPropertyInfo :: *

type AttrLabel WidgetScaleFactorPropertyInfo :: Symbol

type AttrOrigin WidgetScaleFactorPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo o => Proxy * WidgetScaleFactorPropertyInfo -> o -> IO (AttrGetType WidgetScaleFactorPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo o, AttrSetTypeConstraint WidgetScaleFactorPropertyInfo b) => Proxy * WidgetScaleFactorPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo o => Proxy * WidgetScaleFactorPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo o, AttrSetTypeConstraint WidgetScaleFactorPropertyInfo b) => Proxy * WidgetScaleFactorPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetScaleFactorPropertyInfo

type AttrOrigin WidgetScaleFactorPropertyInfo = Widget

type AttrLabel WidgetScaleFactorPropertyInfo

type AttrLabel WidgetScaleFactorPropertyInfo = "scale-factor"

type AttrGetType WidgetScaleFactorPropertyInfo

type AttrGetType WidgetScaleFactorPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo

type AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetScaleFactorPropertyInfo

type AttrSetTypeConstraint WidgetScaleFactorPropertyInfo = * ~ ()

type AttrAllowedOps WidgetScaleFactorPropertyInfo

type AttrAllowedOps WidgetScaleFactorPropertyInfo = (:) AttrOpTag AttrGet ([] AttrOpTag)

getWidgetScaleFactor :: (MonadIO m, IsWidget o) => o -> m Int32

widgetScaleFactor :: AttrLabelProxy "scaleFactor"

sensitive

data WidgetSensitivePropertyInfo

Instances

AttrInfo WidgetSensitivePropertyInfo

Associated Types

type AttrAllowedOps WidgetSensitivePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetSensitivePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetSensitivePropertyInfo :: * -> Constraint

type AttrGetType WidgetSensitivePropertyInfo :: *

type AttrLabel WidgetSensitivePropertyInfo :: Symbol

type AttrOrigin WidgetSensitivePropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetSensitivePropertyInfo o => Proxy * WidgetSensitivePropertyInfo -> o -> IO (AttrGetType WidgetSensitivePropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetSensitivePropertyInfo o, AttrSetTypeConstraint WidgetSensitivePropertyInfo b) => Proxy * WidgetSensitivePropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetSensitivePropertyInfo o => Proxy * WidgetSensitivePropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetSensitivePropertyInfo o, AttrSetTypeConstraint WidgetSensitivePropertyInfo b) => Proxy * WidgetSensitivePropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetSensitivePropertyInfo

type AttrOrigin WidgetSensitivePropertyInfo = Widget

type AttrLabel WidgetSensitivePropertyInfo

type AttrLabel WidgetSensitivePropertyInfo = "sensitive"

type AttrGetType WidgetSensitivePropertyInfo

type AttrGetType WidgetSensitivePropertyInfo = Bool

type AttrBaseTypeConstraint WidgetSensitivePropertyInfo

type AttrBaseTypeConstraint WidgetSensitivePropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetSensitivePropertyInfo

type AttrSetTypeConstraint WidgetSensitivePropertyInfo = * ~ Bool

type AttrAllowedOps WidgetSensitivePropertyInfo

type AttrAllowedOps WidgetSensitivePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetSensitive :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetSensitive :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetSensitive :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetSensitive :: AttrLabelProxy "sensitive"

style

data WidgetStylePropertyInfo

Instances

AttrInfo WidgetStylePropertyInfo

Associated Types

type AttrAllowedOps WidgetStylePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetStylePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetStylePropertyInfo :: * -> Constraint

type AttrGetType WidgetStylePropertyInfo :: *

type AttrLabel WidgetStylePropertyInfo :: Symbol

type AttrOrigin WidgetStylePropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetStylePropertyInfo o => Proxy * WidgetStylePropertyInfo -> o -> IO (AttrGetType WidgetStylePropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetStylePropertyInfo o, AttrSetTypeConstraint WidgetStylePropertyInfo b) => Proxy * WidgetStylePropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetStylePropertyInfo o => Proxy * WidgetStylePropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetStylePropertyInfo o, AttrSetTypeConstraint WidgetStylePropertyInfo b) => Proxy * WidgetStylePropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetStylePropertyInfo

type AttrOrigin WidgetStylePropertyInfo = Widget

type AttrLabel WidgetStylePropertyInfo

type AttrLabel WidgetStylePropertyInfo = "style"

type AttrGetType WidgetStylePropertyInfo

type AttrGetType WidgetStylePropertyInfo = Style

type AttrBaseTypeConstraint WidgetStylePropertyInfo

type AttrBaseTypeConstraint WidgetStylePropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetStylePropertyInfo

type AttrSetTypeConstraint WidgetStylePropertyInfo = IsStyle

type AttrAllowedOps WidgetStylePropertyInfo

type AttrAllowedOps WidgetStylePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearWidgetStyle :: (MonadIO m, IsWidget o) => o -> m ()

constructWidgetStyle :: (IsWidget o, IsStyle a) => a -> IO (GValueConstruct o)

getWidgetStyle :: (MonadIO m, IsWidget o) => o -> m Style

setWidgetStyle :: (MonadIO m, IsWidget o, IsStyle a) => o -> a -> m ()

widgetStyle :: AttrLabelProxy "style"

tooltipMarkup

data WidgetTooltipMarkupPropertyInfo

Instances

AttrInfo WidgetTooltipMarkupPropertyInfo

Associated Types

type AttrAllowedOps WidgetTooltipMarkupPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetTooltipMarkupPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo :: * -> Constraint

type AttrGetType WidgetTooltipMarkupPropertyInfo :: *

type AttrLabel WidgetTooltipMarkupPropertyInfo :: Symbol

type AttrOrigin WidgetTooltipMarkupPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo o => Proxy * WidgetTooltipMarkupPropertyInfo -> o -> IO (AttrGetType WidgetTooltipMarkupPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo o, AttrSetTypeConstraint WidgetTooltipMarkupPropertyInfo b) => Proxy * WidgetTooltipMarkupPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo o => Proxy * WidgetTooltipMarkupPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo o, AttrSetTypeConstraint WidgetTooltipMarkupPropertyInfo b) => Proxy * WidgetTooltipMarkupPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetTooltipMarkupPropertyInfo

type AttrOrigin WidgetTooltipMarkupPropertyInfo = Widget

type AttrLabel WidgetTooltipMarkupPropertyInfo

type AttrLabel WidgetTooltipMarkupPropertyInfo = "tooltip-markup"

type AttrGetType WidgetTooltipMarkupPropertyInfo

type AttrGetType WidgetTooltipMarkupPropertyInfo = Maybe Text

type AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo

type AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetTooltipMarkupPropertyInfo

type AttrSetTypeConstraint WidgetTooltipMarkupPropertyInfo = * ~ Text

type AttrAllowedOps WidgetTooltipMarkupPropertyInfo

type AttrAllowedOps WidgetTooltipMarkupPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m ()

constructWidgetTooltipMarkup :: IsWidget o => Text -> IO (GValueConstruct o)

getWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

setWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> Text -> m ()

widgetTooltipMarkup :: AttrLabelProxy "tooltipMarkup"

tooltipText

data WidgetTooltipTextPropertyInfo

Instances

AttrInfo WidgetTooltipTextPropertyInfo

Associated Types

type AttrAllowedOps WidgetTooltipTextPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetTooltipTextPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo :: * -> Constraint

type AttrGetType WidgetTooltipTextPropertyInfo :: *

type AttrLabel WidgetTooltipTextPropertyInfo :: Symbol

type AttrOrigin WidgetTooltipTextPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo o => Proxy * WidgetTooltipTextPropertyInfo -> o -> IO (AttrGetType WidgetTooltipTextPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo o, AttrSetTypeConstraint WidgetTooltipTextPropertyInfo b) => Proxy * WidgetTooltipTextPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo o => Proxy * WidgetTooltipTextPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo o, AttrSetTypeConstraint WidgetTooltipTextPropertyInfo b) => Proxy * WidgetTooltipTextPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetTooltipTextPropertyInfo

type AttrOrigin WidgetTooltipTextPropertyInfo = Widget

type AttrLabel WidgetTooltipTextPropertyInfo

type AttrLabel WidgetTooltipTextPropertyInfo = "tooltip-text"

type AttrGetType WidgetTooltipTextPropertyInfo

type AttrGetType WidgetTooltipTextPropertyInfo = Maybe Text

type AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo

type AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetTooltipTextPropertyInfo

type AttrSetTypeConstraint WidgetTooltipTextPropertyInfo = * ~ Text

type AttrAllowedOps WidgetTooltipTextPropertyInfo

type AttrAllowedOps WidgetTooltipTextPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m ()

constructWidgetTooltipText :: IsWidget o => Text -> IO (GValueConstruct o)

getWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

setWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> Text -> m ()

widgetTooltipText :: AttrLabelProxy "tooltipText"

valign

data WidgetValignPropertyInfo

Instances

AttrInfo WidgetValignPropertyInfo

Associated Types

type AttrAllowedOps WidgetValignPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetValignPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetValignPropertyInfo :: * -> Constraint

type AttrGetType WidgetValignPropertyInfo :: *

type AttrLabel WidgetValignPropertyInfo :: Symbol

type AttrOrigin WidgetValignPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetValignPropertyInfo o => Proxy * WidgetValignPropertyInfo -> o -> IO (AttrGetType WidgetValignPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetValignPropertyInfo o, AttrSetTypeConstraint WidgetValignPropertyInfo b) => Proxy * WidgetValignPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetValignPropertyInfo o => Proxy * WidgetValignPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetValignPropertyInfo o, AttrSetTypeConstraint WidgetValignPropertyInfo b) => Proxy * WidgetValignPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetValignPropertyInfo

type AttrOrigin WidgetValignPropertyInfo = Widget

type AttrLabel WidgetValignPropertyInfo

type AttrLabel WidgetValignPropertyInfo = "valign"

type AttrGetType WidgetValignPropertyInfo

type AttrGetType WidgetValignPropertyInfo = Align

type AttrBaseTypeConstraint WidgetValignPropertyInfo

type AttrBaseTypeConstraint WidgetValignPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetValignPropertyInfo

type AttrSetTypeConstraint WidgetValignPropertyInfo = * ~ Align

type AttrAllowedOps WidgetValignPropertyInfo

type AttrAllowedOps WidgetValignPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetValign :: IsWidget o => Align -> IO (GValueConstruct o)

getWidgetValign :: (MonadIO m, IsWidget o) => o -> m Align

setWidgetValign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

widgetValign :: AttrLabelProxy "valign"

vexpand

data WidgetVexpandPropertyInfo

Instances

AttrInfo WidgetVexpandPropertyInfo

Associated Types

type AttrAllowedOps WidgetVexpandPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetVexpandPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetVexpandPropertyInfo :: * -> Constraint

type AttrGetType WidgetVexpandPropertyInfo :: *

type AttrLabel WidgetVexpandPropertyInfo :: Symbol

type AttrOrigin WidgetVexpandPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetVexpandPropertyInfo o => Proxy * WidgetVexpandPropertyInfo -> o -> IO (AttrGetType WidgetVexpandPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetVexpandPropertyInfo o, AttrSetTypeConstraint WidgetVexpandPropertyInfo b) => Proxy * WidgetVexpandPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetVexpandPropertyInfo o => Proxy * WidgetVexpandPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetVexpandPropertyInfo o, AttrSetTypeConstraint WidgetVexpandPropertyInfo b) => Proxy * WidgetVexpandPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetVexpandPropertyInfo

type AttrOrigin WidgetVexpandPropertyInfo = Widget

type AttrLabel WidgetVexpandPropertyInfo

type AttrLabel WidgetVexpandPropertyInfo = "vexpand"

type AttrGetType WidgetVexpandPropertyInfo

type AttrGetType WidgetVexpandPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetVexpandPropertyInfo

type AttrBaseTypeConstraint WidgetVexpandPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetVexpandPropertyInfo

type AttrSetTypeConstraint WidgetVexpandPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetVexpandPropertyInfo

type AttrAllowedOps WidgetVexpandPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetVexpand :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetVexpand :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetVexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetVexpand :: AttrLabelProxy "vexpand"

vexpandSet

data WidgetVexpandSetPropertyInfo

Instances

AttrInfo WidgetVexpandSetPropertyInfo

Associated Types

type AttrAllowedOps WidgetVexpandSetPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetVexpandSetPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo :: * -> Constraint

type AttrGetType WidgetVexpandSetPropertyInfo :: *

type AttrLabel WidgetVexpandSetPropertyInfo :: Symbol

type AttrOrigin WidgetVexpandSetPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo o => Proxy * WidgetVexpandSetPropertyInfo -> o -> IO (AttrGetType WidgetVexpandSetPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo o, AttrSetTypeConstraint WidgetVexpandSetPropertyInfo b) => Proxy * WidgetVexpandSetPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo o => Proxy * WidgetVexpandSetPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo o, AttrSetTypeConstraint WidgetVexpandSetPropertyInfo b) => Proxy * WidgetVexpandSetPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetVexpandSetPropertyInfo

type AttrOrigin WidgetVexpandSetPropertyInfo = Widget

type AttrLabel WidgetVexpandSetPropertyInfo

type AttrLabel WidgetVexpandSetPropertyInfo = "vexpand-set"

type AttrGetType WidgetVexpandSetPropertyInfo

type AttrGetType WidgetVexpandSetPropertyInfo = Bool

type AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo

type AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetVexpandSetPropertyInfo

type AttrSetTypeConstraint WidgetVexpandSetPropertyInfo = * ~ Bool

type AttrAllowedOps WidgetVexpandSetPropertyInfo

type AttrAllowedOps WidgetVexpandSetPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetVexpandSet :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetVexpandSet :: AttrLabelProxy "vexpandSet"

visible

data WidgetVisiblePropertyInfo

Instances

AttrInfo WidgetVisiblePropertyInfo

Associated Types

type AttrAllowedOps WidgetVisiblePropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetVisiblePropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetVisiblePropertyInfo :: * -> Constraint

type AttrGetType WidgetVisiblePropertyInfo :: *

type AttrLabel WidgetVisiblePropertyInfo :: Symbol

type AttrOrigin WidgetVisiblePropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetVisiblePropertyInfo o => Proxy * WidgetVisiblePropertyInfo -> o -> IO (AttrGetType WidgetVisiblePropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetVisiblePropertyInfo o, AttrSetTypeConstraint WidgetVisiblePropertyInfo b) => Proxy * WidgetVisiblePropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetVisiblePropertyInfo o => Proxy * WidgetVisiblePropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetVisiblePropertyInfo o, AttrSetTypeConstraint WidgetVisiblePropertyInfo b) => Proxy * WidgetVisiblePropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetVisiblePropertyInfo

type AttrOrigin WidgetVisiblePropertyInfo = Widget

type AttrLabel WidgetVisiblePropertyInfo

type AttrLabel WidgetVisiblePropertyInfo = "visible"

type AttrGetType WidgetVisiblePropertyInfo

type AttrGetType WidgetVisiblePropertyInfo = Bool

type AttrBaseTypeConstraint WidgetVisiblePropertyInfo

type AttrBaseTypeConstraint WidgetVisiblePropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetVisiblePropertyInfo

type AttrSetTypeConstraint WidgetVisiblePropertyInfo = * ~ Bool

type AttrAllowedOps WidgetVisiblePropertyInfo

type AttrAllowedOps WidgetVisiblePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetVisible :: IsWidget o => Bool -> IO (GValueConstruct o)

getWidgetVisible :: (MonadIO m, IsWidget o) => o -> m Bool

setWidgetVisible :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

widgetVisible :: AttrLabelProxy "visible"

widthRequest

data WidgetWidthRequestPropertyInfo

Instances

AttrInfo WidgetWidthRequestPropertyInfo

Associated Types

type AttrAllowedOps WidgetWidthRequestPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetWidthRequestPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo :: * -> Constraint

type AttrGetType WidgetWidthRequestPropertyInfo :: *

type AttrLabel WidgetWidthRequestPropertyInfo :: Symbol

type AttrOrigin WidgetWidthRequestPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo o => Proxy * WidgetWidthRequestPropertyInfo -> o -> IO (AttrGetType WidgetWidthRequestPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo o, AttrSetTypeConstraint WidgetWidthRequestPropertyInfo b) => Proxy * WidgetWidthRequestPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo o => Proxy * WidgetWidthRequestPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo o, AttrSetTypeConstraint WidgetWidthRequestPropertyInfo b) => Proxy * WidgetWidthRequestPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetWidthRequestPropertyInfo

type AttrOrigin WidgetWidthRequestPropertyInfo = Widget

type AttrLabel WidgetWidthRequestPropertyInfo

type AttrLabel WidgetWidthRequestPropertyInfo = "width-request"

type AttrGetType WidgetWidthRequestPropertyInfo

type AttrGetType WidgetWidthRequestPropertyInfo = Int32

type AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo

type AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetWidthRequestPropertyInfo

type AttrSetTypeConstraint WidgetWidthRequestPropertyInfo = * ~ Int32

type AttrAllowedOps WidgetWidthRequestPropertyInfo

type AttrAllowedOps WidgetWidthRequestPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructWidgetWidthRequest :: IsWidget o => Int32 -> IO (GValueConstruct o)

getWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> m Int32

setWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

widgetWidthRequest :: AttrLabelProxy "widthRequest"

window

data WidgetWindowPropertyInfo

Instances

AttrInfo WidgetWindowPropertyInfo

Associated Types

type AttrAllowedOps WidgetWindowPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint WidgetWindowPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint WidgetWindowPropertyInfo :: * -> Constraint

type AttrGetType WidgetWindowPropertyInfo :: *

type AttrLabel WidgetWindowPropertyInfo :: Symbol

type AttrOrigin WidgetWindowPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint WidgetWindowPropertyInfo o => Proxy * WidgetWindowPropertyInfo -> o -> IO (AttrGetType WidgetWindowPropertyInfo)

attrSet :: (AttrBaseTypeConstraint WidgetWindowPropertyInfo o, AttrSetTypeConstraint WidgetWindowPropertyInfo b) => Proxy * WidgetWindowPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint WidgetWindowPropertyInfo o => Proxy * WidgetWindowPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint WidgetWindowPropertyInfo o, AttrSetTypeConstraint WidgetWindowPropertyInfo b) => Proxy * WidgetWindowPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin WidgetWindowPropertyInfo

type AttrOrigin WidgetWindowPropertyInfo = Widget

type AttrLabel WidgetWindowPropertyInfo

type AttrLabel WidgetWindowPropertyInfo = "window"

type AttrGetType WidgetWindowPropertyInfo

type AttrGetType WidgetWindowPropertyInfo = Maybe Window

type AttrBaseTypeConstraint WidgetWindowPropertyInfo

type AttrBaseTypeConstraint WidgetWindowPropertyInfo = IsWidget

type AttrSetTypeConstraint WidgetWindowPropertyInfo

type AttrSetTypeConstraint WidgetWindowPropertyInfo = * ~ ()

type AttrAllowedOps WidgetWindowPropertyInfo

type AttrAllowedOps WidgetWindowPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getWidgetWindow :: (MonadIO m, IsWidget o) => o -> m (Maybe Window)

widgetWindow :: AttrLabelProxy "window"

Signals

accelClosuresChanged

type C_WidgetAccelClosuresChangedCallback = Ptr () -> Ptr () -> IO ()

type WidgetAccelClosuresChangedCallback = IO ()

data WidgetAccelClosuresChangedSignalInfo

Instances

SignalInfo WidgetAccelClosuresChangedSignalInfo

Associated Types

type HaskellCallbackType WidgetAccelClosuresChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetAccelClosuresChangedSignalInfo -> o -> HaskellCallbackType WidgetAccelClosuresChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetAccelClosuresChangedSignalInfo

type HaskellCallbackType WidgetAccelClosuresChangedSignalInfo = WidgetAccelClosuresChangedCallback

afterWidgetAccelClosuresChanged :: (GObject a, MonadIO m) => a -> WidgetAccelClosuresChangedCallback -> m SignalHandlerId

genClosure_WidgetAccelClosuresChanged :: WidgetAccelClosuresChangedCallback -> IO Closure

mk_WidgetAccelClosuresChangedCallback :: C_WidgetAccelClosuresChangedCallback -> IO (FunPtr C_WidgetAccelClosuresChangedCallback)

noWidgetAccelClosuresChangedCallback :: Maybe WidgetAccelClosuresChangedCallback

onWidgetAccelClosuresChanged :: (GObject a, MonadIO m) => a -> WidgetAccelClosuresChangedCallback -> m SignalHandlerId

wrap_WidgetAccelClosuresChangedCallback :: WidgetAccelClosuresChangedCallback -> Ptr () -> Ptr () -> IO ()

buttonPressEvent

type C_WidgetButtonPressEventCallback = Ptr () -> Ptr EventButton -> Ptr () -> IO CInt

type WidgetButtonPressEventCallback = EventButton -> IO Bool

data WidgetButtonPressEventSignalInfo

Instances

SignalInfo WidgetButtonPressEventSignalInfo

Associated Types

type HaskellCallbackType WidgetButtonPressEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetButtonPressEventSignalInfo -> o -> HaskellCallbackType WidgetButtonPressEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetButtonPressEventSignalInfo

type HaskellCallbackType WidgetButtonPressEventSignalInfo = WidgetButtonPressEventCallback

afterWidgetButtonPressEvent :: (GObject a, MonadIO m) => a -> WidgetButtonPressEventCallback -> m SignalHandlerId

genClosure_WidgetButtonPressEvent :: WidgetButtonPressEventCallback -> IO Closure

mk_WidgetButtonPressEventCallback :: C_WidgetButtonPressEventCallback -> IO (FunPtr C_WidgetButtonPressEventCallback)

noWidgetButtonPressEventCallback :: Maybe WidgetButtonPressEventCallback

onWidgetButtonPressEvent :: (GObject a, MonadIO m) => a -> WidgetButtonPressEventCallback -> m SignalHandlerId

wrap_WidgetButtonPressEventCallback :: WidgetButtonPressEventCallback -> Ptr () -> Ptr EventButton -> Ptr () -> IO CInt

buttonReleaseEvent

type C_WidgetButtonReleaseEventCallback = Ptr () -> Ptr EventButton -> Ptr () -> IO CInt

type WidgetButtonReleaseEventCallback = EventButton -> IO Bool

data WidgetButtonReleaseEventSignalInfo

Instances

SignalInfo WidgetButtonReleaseEventSignalInfo

Associated Types

type HaskellCallbackType WidgetButtonReleaseEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetButtonReleaseEventSignalInfo -> o -> HaskellCallbackType WidgetButtonReleaseEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetButtonReleaseEventSignalInfo

type HaskellCallbackType WidgetButtonReleaseEventSignalInfo = WidgetButtonReleaseEventCallback

afterWidgetButtonReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetButtonReleaseEventCallback -> m SignalHandlerId

genClosure_WidgetButtonReleaseEvent :: WidgetButtonReleaseEventCallback -> IO Closure

mk_WidgetButtonReleaseEventCallback :: C_WidgetButtonReleaseEventCallback -> IO (FunPtr C_WidgetButtonReleaseEventCallback)

noWidgetButtonReleaseEventCallback :: Maybe WidgetButtonReleaseEventCallback

onWidgetButtonReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetButtonReleaseEventCallback -> m SignalHandlerId

wrap_WidgetButtonReleaseEventCallback :: WidgetButtonReleaseEventCallback -> Ptr () -> Ptr EventButton -> Ptr () -> IO CInt

canActivateAccel

type C_WidgetCanActivateAccelCallback = Ptr () -> Word32 -> Ptr () -> IO CInt

type WidgetCanActivateAccelCallback = Word32 -> IO Bool

data WidgetCanActivateAccelSignalInfo

Instances

SignalInfo WidgetCanActivateAccelSignalInfo

Associated Types

type HaskellCallbackType WidgetCanActivateAccelSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetCanActivateAccelSignalInfo -> o -> HaskellCallbackType WidgetCanActivateAccelSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetCanActivateAccelSignalInfo

type HaskellCallbackType WidgetCanActivateAccelSignalInfo = WidgetCanActivateAccelCallback

afterWidgetCanActivateAccel :: (GObject a, MonadIO m) => a -> WidgetCanActivateAccelCallback -> m SignalHandlerId

genClosure_WidgetCanActivateAccel :: WidgetCanActivateAccelCallback -> IO Closure

mk_WidgetCanActivateAccelCallback :: C_WidgetCanActivateAccelCallback -> IO (FunPtr C_WidgetCanActivateAccelCallback)

noWidgetCanActivateAccelCallback :: Maybe WidgetCanActivateAccelCallback

onWidgetCanActivateAccel :: (GObject a, MonadIO m) => a -> WidgetCanActivateAccelCallback -> m SignalHandlerId

wrap_WidgetCanActivateAccelCallback :: WidgetCanActivateAccelCallback -> Ptr () -> Word32 -> Ptr () -> IO CInt

childNotify

type C_WidgetChildNotifyCallback = Ptr () -> Ptr GParamSpec -> Ptr () -> IO ()

type WidgetChildNotifyCallback = GParamSpec -> IO ()

data WidgetChildNotifySignalInfo

Instances

SignalInfo WidgetChildNotifySignalInfo

Associated Types

type HaskellCallbackType WidgetChildNotifySignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetChildNotifySignalInfo -> o -> HaskellCallbackType WidgetChildNotifySignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetChildNotifySignalInfo

type HaskellCallbackType WidgetChildNotifySignalInfo = WidgetChildNotifyCallback

afterWidgetChildNotify :: (GObject a, MonadIO m) => a -> WidgetChildNotifyCallback -> m SignalHandlerId

genClosure_WidgetChildNotify :: WidgetChildNotifyCallback -> IO Closure

mk_WidgetChildNotifyCallback :: C_WidgetChildNotifyCallback -> IO (FunPtr C_WidgetChildNotifyCallback)

noWidgetChildNotifyCallback :: Maybe WidgetChildNotifyCallback

onWidgetChildNotify :: (GObject a, MonadIO m) => a -> WidgetChildNotifyCallback -> m SignalHandlerId

wrap_WidgetChildNotifyCallback :: WidgetChildNotifyCallback -> Ptr () -> Ptr GParamSpec -> Ptr () -> IO ()

compositedChanged

type C_WidgetCompositedChangedCallback = Ptr () -> Ptr () -> IO ()

type WidgetCompositedChangedCallback = IO ()

Deprecated: (Since version 3.22)Use GdkScreen::composited-changed instead.

data WidgetCompositedChangedSignalInfo

Instances

SignalInfo WidgetCompositedChangedSignalInfo

Associated Types

type HaskellCallbackType WidgetCompositedChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetCompositedChangedSignalInfo -> o -> HaskellCallbackType WidgetCompositedChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetCompositedChangedSignalInfo

type HaskellCallbackType WidgetCompositedChangedSignalInfo = WidgetCompositedChangedCallback

afterWidgetCompositedChanged :: (GObject a, MonadIO m) => a -> WidgetCompositedChangedCallback -> m SignalHandlerId

genClosure_WidgetCompositedChanged :: WidgetCompositedChangedCallback -> IO Closure

mk_WidgetCompositedChangedCallback :: C_WidgetCompositedChangedCallback -> IO (FunPtr C_WidgetCompositedChangedCallback)

noWidgetCompositedChangedCallback :: Maybe WidgetCompositedChangedCallback

onWidgetCompositedChanged :: (GObject a, MonadIO m) => a -> WidgetCompositedChangedCallback -> m SignalHandlerId

wrap_WidgetCompositedChangedCallback :: WidgetCompositedChangedCallback -> Ptr () -> Ptr () -> IO ()

configureEvent

type C_WidgetConfigureEventCallback = Ptr () -> Ptr EventConfigure -> Ptr () -> IO CInt

type WidgetConfigureEventCallback = EventConfigure -> IO Bool

data WidgetConfigureEventSignalInfo

Instances

SignalInfo WidgetConfigureEventSignalInfo

Associated Types

type HaskellCallbackType WidgetConfigureEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetConfigureEventSignalInfo -> o -> HaskellCallbackType WidgetConfigureEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetConfigureEventSignalInfo

type HaskellCallbackType WidgetConfigureEventSignalInfo = WidgetConfigureEventCallback

afterWidgetConfigureEvent :: (GObject a, MonadIO m) => a -> WidgetConfigureEventCallback -> m SignalHandlerId

genClosure_WidgetConfigureEvent :: WidgetConfigureEventCallback -> IO Closure

mk_WidgetConfigureEventCallback :: C_WidgetConfigureEventCallback -> IO (FunPtr C_WidgetConfigureEventCallback)

noWidgetConfigureEventCallback :: Maybe WidgetConfigureEventCallback

onWidgetConfigureEvent :: (GObject a, MonadIO m) => a -> WidgetConfigureEventCallback -> m SignalHandlerId

wrap_WidgetConfigureEventCallback :: WidgetConfigureEventCallback -> Ptr () -> Ptr EventConfigure -> Ptr () -> IO CInt

damageEvent

type C_WidgetDamageEventCallback = Ptr () -> Ptr EventExpose -> Ptr () -> IO CInt

type WidgetDamageEventCallback = EventExpose -> IO Bool

data WidgetDamageEventSignalInfo

Instances

SignalInfo WidgetDamageEventSignalInfo

Associated Types

type HaskellCallbackType WidgetDamageEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDamageEventSignalInfo -> o -> HaskellCallbackType WidgetDamageEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDamageEventSignalInfo

type HaskellCallbackType WidgetDamageEventSignalInfo = WidgetDamageEventCallback

afterWidgetDamageEvent :: (GObject a, MonadIO m) => a -> WidgetDamageEventCallback -> m SignalHandlerId

genClosure_WidgetDamageEvent :: WidgetDamageEventCallback -> IO Closure

mk_WidgetDamageEventCallback :: C_WidgetDamageEventCallback -> IO (FunPtr C_WidgetDamageEventCallback)

noWidgetDamageEventCallback :: Maybe WidgetDamageEventCallback

onWidgetDamageEvent :: (GObject a, MonadIO m) => a -> WidgetDamageEventCallback -> m SignalHandlerId

wrap_WidgetDamageEventCallback :: WidgetDamageEventCallback -> Ptr () -> Ptr EventExpose -> Ptr () -> IO CInt

deleteEvent

type C_WidgetDeleteEventCallback = Ptr () -> Ptr Event -> Ptr () -> IO CInt

type WidgetDeleteEventCallback = Event -> IO Bool

data WidgetDeleteEventSignalInfo

Instances

SignalInfo WidgetDeleteEventSignalInfo

Associated Types

type HaskellCallbackType WidgetDeleteEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDeleteEventSignalInfo -> o -> HaskellCallbackType WidgetDeleteEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDeleteEventSignalInfo

type HaskellCallbackType WidgetDeleteEventSignalInfo = WidgetDeleteEventCallback

afterWidgetDeleteEvent :: (GObject a, MonadIO m) => a -> WidgetDeleteEventCallback -> m SignalHandlerId

genClosure_WidgetDeleteEvent :: WidgetDeleteEventCallback -> IO Closure

mk_WidgetDeleteEventCallback :: C_WidgetDeleteEventCallback -> IO (FunPtr C_WidgetDeleteEventCallback)

noWidgetDeleteEventCallback :: Maybe WidgetDeleteEventCallback

onWidgetDeleteEvent :: (GObject a, MonadIO m) => a -> WidgetDeleteEventCallback -> m SignalHandlerId

wrap_WidgetDeleteEventCallback :: WidgetDeleteEventCallback -> Ptr () -> Ptr Event -> Ptr () -> IO CInt

destroy

type C_WidgetDestroyCallback = Ptr () -> Ptr () -> IO ()

type WidgetDestroyCallback = IO ()

data WidgetDestroySignalInfo

Instances

SignalInfo WidgetDestroySignalInfo

Associated Types

type HaskellCallbackType WidgetDestroySignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDestroySignalInfo -> o -> HaskellCallbackType WidgetDestroySignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDestroySignalInfo

type HaskellCallbackType WidgetDestroySignalInfo = WidgetDestroyCallback

afterWidgetDestroy :: (GObject a, MonadIO m) => a -> WidgetDestroyCallback -> m SignalHandlerId

genClosure_WidgetDestroy :: WidgetDestroyCallback -> IO Closure

mk_WidgetDestroyCallback :: C_WidgetDestroyCallback -> IO (FunPtr C_WidgetDestroyCallback)

noWidgetDestroyCallback :: Maybe WidgetDestroyCallback

onWidgetDestroy :: (GObject a, MonadIO m) => a -> WidgetDestroyCallback -> m SignalHandlerId

wrap_WidgetDestroyCallback :: WidgetDestroyCallback -> Ptr () -> Ptr () -> IO ()

destroyEvent

type C_WidgetDestroyEventCallback = Ptr () -> Ptr Event -> Ptr () -> IO CInt

type WidgetDestroyEventCallback = Event -> IO Bool

data WidgetDestroyEventSignalInfo

Instances

SignalInfo WidgetDestroyEventSignalInfo

Associated Types

type HaskellCallbackType WidgetDestroyEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDestroyEventSignalInfo -> o -> HaskellCallbackType WidgetDestroyEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDestroyEventSignalInfo

type HaskellCallbackType WidgetDestroyEventSignalInfo = WidgetDestroyEventCallback

afterWidgetDestroyEvent :: (GObject a, MonadIO m) => a -> WidgetDestroyEventCallback -> m SignalHandlerId

genClosure_WidgetDestroyEvent :: WidgetDestroyEventCallback -> IO Closure

mk_WidgetDestroyEventCallback :: C_WidgetDestroyEventCallback -> IO (FunPtr C_WidgetDestroyEventCallback)

noWidgetDestroyEventCallback :: Maybe WidgetDestroyEventCallback

onWidgetDestroyEvent :: (GObject a, MonadIO m) => a -> WidgetDestroyEventCallback -> m SignalHandlerId

wrap_WidgetDestroyEventCallback :: WidgetDestroyEventCallback -> Ptr () -> Ptr Event -> Ptr () -> IO CInt

directionChanged

type C_WidgetDirectionChangedCallback = Ptr () -> CUInt -> Ptr () -> IO ()

type WidgetDirectionChangedCallback = TextDirection -> IO ()

data WidgetDirectionChangedSignalInfo

Instances

SignalInfo WidgetDirectionChangedSignalInfo

Associated Types

type HaskellCallbackType WidgetDirectionChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDirectionChangedSignalInfo -> o -> HaskellCallbackType WidgetDirectionChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDirectionChangedSignalInfo

type HaskellCallbackType WidgetDirectionChangedSignalInfo = WidgetDirectionChangedCallback

afterWidgetDirectionChanged :: (GObject a, MonadIO m) => a -> WidgetDirectionChangedCallback -> m SignalHandlerId

genClosure_WidgetDirectionChanged :: WidgetDirectionChangedCallback -> IO Closure

mk_WidgetDirectionChangedCallback :: C_WidgetDirectionChangedCallback -> IO (FunPtr C_WidgetDirectionChangedCallback)

noWidgetDirectionChangedCallback :: Maybe WidgetDirectionChangedCallback

onWidgetDirectionChanged :: (GObject a, MonadIO m) => a -> WidgetDirectionChangedCallback -> m SignalHandlerId

wrap_WidgetDirectionChangedCallback :: WidgetDirectionChangedCallback -> Ptr () -> CUInt -> Ptr () -> IO ()

dragBegin

type C_WidgetDragBeginCallback = Ptr () -> Ptr DragContext -> Ptr () -> IO ()

type WidgetDragBeginCallback = DragContext -> IO ()

data WidgetDragBeginSignalInfo

Instances

SignalInfo WidgetDragBeginSignalInfo

Associated Types

type HaskellCallbackType WidgetDragBeginSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragBeginSignalInfo -> o -> HaskellCallbackType WidgetDragBeginSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragBeginSignalInfo

type HaskellCallbackType WidgetDragBeginSignalInfo = WidgetDragBeginCallback

afterWidgetDragBegin :: (GObject a, MonadIO m) => a -> WidgetDragBeginCallback -> m SignalHandlerId

genClosure_WidgetDragBegin :: WidgetDragBeginCallback -> IO Closure

mk_WidgetDragBeginCallback :: C_WidgetDragBeginCallback -> IO (FunPtr C_WidgetDragBeginCallback)

noWidgetDragBeginCallback :: Maybe WidgetDragBeginCallback

onWidgetDragBegin :: (GObject a, MonadIO m) => a -> WidgetDragBeginCallback -> m SignalHandlerId

wrap_WidgetDragBeginCallback :: WidgetDragBeginCallback -> Ptr () -> Ptr DragContext -> Ptr () -> IO ()

dragDataDelete

type C_WidgetDragDataDeleteCallback = Ptr () -> Ptr DragContext -> Ptr () -> IO ()

type WidgetDragDataDeleteCallback = DragContext -> IO ()

data WidgetDragDataDeleteSignalInfo

Instances

SignalInfo WidgetDragDataDeleteSignalInfo

Associated Types

type HaskellCallbackType WidgetDragDataDeleteSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragDataDeleteSignalInfo -> o -> HaskellCallbackType WidgetDragDataDeleteSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragDataDeleteSignalInfo

type HaskellCallbackType WidgetDragDataDeleteSignalInfo = WidgetDragDataDeleteCallback

afterWidgetDragDataDelete :: (GObject a, MonadIO m) => a -> WidgetDragDataDeleteCallback -> m SignalHandlerId

genClosure_WidgetDragDataDelete :: WidgetDragDataDeleteCallback -> IO Closure

mk_WidgetDragDataDeleteCallback :: C_WidgetDragDataDeleteCallback -> IO (FunPtr C_WidgetDragDataDeleteCallback)

noWidgetDragDataDeleteCallback :: Maybe WidgetDragDataDeleteCallback

onWidgetDragDataDelete :: (GObject a, MonadIO m) => a -> WidgetDragDataDeleteCallback -> m SignalHandlerId

wrap_WidgetDragDataDeleteCallback :: WidgetDragDataDeleteCallback -> Ptr () -> Ptr DragContext -> Ptr () -> IO ()

dragDataGet

type C_WidgetDragDataGetCallback = Ptr () -> Ptr DragContext -> Ptr SelectionData -> Word32 -> Word32 -> Ptr () -> IO ()

type WidgetDragDataGetCallback = DragContext -> SelectionData -> Word32 -> Word32 -> IO ()

data WidgetDragDataGetSignalInfo

Instances

SignalInfo WidgetDragDataGetSignalInfo

Associated Types

type HaskellCallbackType WidgetDragDataGetSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragDataGetSignalInfo -> o -> HaskellCallbackType WidgetDragDataGetSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragDataGetSignalInfo

type HaskellCallbackType WidgetDragDataGetSignalInfo = WidgetDragDataGetCallback

afterWidgetDragDataGet :: (GObject a, MonadIO m) => a -> WidgetDragDataGetCallback -> m SignalHandlerId

genClosure_WidgetDragDataGet :: WidgetDragDataGetCallback -> IO Closure

mk_WidgetDragDataGetCallback :: C_WidgetDragDataGetCallback -> IO (FunPtr C_WidgetDragDataGetCallback)

noWidgetDragDataGetCallback :: Maybe WidgetDragDataGetCallback

onWidgetDragDataGet :: (GObject a, MonadIO m) => a -> WidgetDragDataGetCallback -> m SignalHandlerId

wrap_WidgetDragDataGetCallback :: WidgetDragDataGetCallback -> Ptr () -> Ptr DragContext -> Ptr SelectionData -> Word32 -> Word32 -> Ptr () -> IO ()

dragDataReceived

type C_WidgetDragDataReceivedCallback = Ptr () -> Ptr DragContext -> Int32 -> Int32 -> Ptr SelectionData -> Word32 -> Word32 -> Ptr () -> IO ()

type WidgetDragDataReceivedCallback = DragContext -> Int32 -> Int32 -> SelectionData -> Word32 -> Word32 -> IO ()

data WidgetDragDataReceivedSignalInfo

Instances

SignalInfo WidgetDragDataReceivedSignalInfo

Associated Types

type HaskellCallbackType WidgetDragDataReceivedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragDataReceivedSignalInfo -> o -> HaskellCallbackType WidgetDragDataReceivedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragDataReceivedSignalInfo

type HaskellCallbackType WidgetDragDataReceivedSignalInfo = WidgetDragDataReceivedCallback

afterWidgetDragDataReceived :: (GObject a, MonadIO m) => a -> WidgetDragDataReceivedCallback -> m SignalHandlerId

genClosure_WidgetDragDataReceived :: WidgetDragDataReceivedCallback -> IO Closure

mk_WidgetDragDataReceivedCallback :: C_WidgetDragDataReceivedCallback -> IO (FunPtr C_WidgetDragDataReceivedCallback)

noWidgetDragDataReceivedCallback :: Maybe WidgetDragDataReceivedCallback

onWidgetDragDataReceived :: (GObject a, MonadIO m) => a -> WidgetDragDataReceivedCallback -> m SignalHandlerId

wrap_WidgetDragDataReceivedCallback :: WidgetDragDataReceivedCallback -> Ptr () -> Ptr DragContext -> Int32 -> Int32 -> Ptr SelectionData -> Word32 -> Word32 -> Ptr () -> IO ()

dragDrop

type C_WidgetDragDropCallback = Ptr () -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> Ptr () -> IO CInt

type WidgetDragDropCallback = DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

data WidgetDragDropSignalInfo

Instances

SignalInfo WidgetDragDropSignalInfo

Associated Types

type HaskellCallbackType WidgetDragDropSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragDropSignalInfo -> o -> HaskellCallbackType WidgetDragDropSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragDropSignalInfo

type HaskellCallbackType WidgetDragDropSignalInfo = WidgetDragDropCallback

afterWidgetDragDrop :: (GObject a, MonadIO m) => a -> WidgetDragDropCallback -> m SignalHandlerId

genClosure_WidgetDragDrop :: WidgetDragDropCallback -> IO Closure

mk_WidgetDragDropCallback :: C_WidgetDragDropCallback -> IO (FunPtr C_WidgetDragDropCallback)

noWidgetDragDropCallback :: Maybe WidgetDragDropCallback

onWidgetDragDrop :: (GObject a, MonadIO m) => a -> WidgetDragDropCallback -> m SignalHandlerId

wrap_WidgetDragDropCallback :: WidgetDragDropCallback -> Ptr () -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> Ptr () -> IO CInt

dragEnd

type C_WidgetDragEndCallback = Ptr () -> Ptr DragContext -> Ptr () -> IO ()

type WidgetDragEndCallback = DragContext -> IO ()

data WidgetDragEndSignalInfo

Instances

SignalInfo WidgetDragEndSignalInfo

Associated Types

type HaskellCallbackType WidgetDragEndSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragEndSignalInfo -> o -> HaskellCallbackType WidgetDragEndSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragEndSignalInfo

type HaskellCallbackType WidgetDragEndSignalInfo = WidgetDragEndCallback

afterWidgetDragEnd :: (GObject a, MonadIO m) => a -> WidgetDragEndCallback -> m SignalHandlerId

genClosure_WidgetDragEnd :: WidgetDragEndCallback -> IO Closure

mk_WidgetDragEndCallback :: C_WidgetDragEndCallback -> IO (FunPtr C_WidgetDragEndCallback)

noWidgetDragEndCallback :: Maybe WidgetDragEndCallback

onWidgetDragEnd :: (GObject a, MonadIO m) => a -> WidgetDragEndCallback -> m SignalHandlerId

wrap_WidgetDragEndCallback :: WidgetDragEndCallback -> Ptr () -> Ptr DragContext -> Ptr () -> IO ()

dragFailed

type C_WidgetDragFailedCallback = Ptr () -> Ptr DragContext -> CUInt -> Ptr () -> IO CInt

type WidgetDragFailedCallback = DragContext -> DragResult -> IO Bool

data WidgetDragFailedSignalInfo

Instances

SignalInfo WidgetDragFailedSignalInfo

Associated Types

type HaskellCallbackType WidgetDragFailedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragFailedSignalInfo -> o -> HaskellCallbackType WidgetDragFailedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragFailedSignalInfo

type HaskellCallbackType WidgetDragFailedSignalInfo = WidgetDragFailedCallback

afterWidgetDragFailed :: (GObject a, MonadIO m) => a -> WidgetDragFailedCallback -> m SignalHandlerId

genClosure_WidgetDragFailed :: WidgetDragFailedCallback -> IO Closure

mk_WidgetDragFailedCallback :: C_WidgetDragFailedCallback -> IO (FunPtr C_WidgetDragFailedCallback)

noWidgetDragFailedCallback :: Maybe WidgetDragFailedCallback

onWidgetDragFailed :: (GObject a, MonadIO m) => a -> WidgetDragFailedCallback -> m SignalHandlerId

wrap_WidgetDragFailedCallback :: WidgetDragFailedCallback -> Ptr () -> Ptr DragContext -> CUInt -> Ptr () -> IO CInt

dragLeave

type C_WidgetDragLeaveCallback = Ptr () -> Ptr DragContext -> Word32 -> Ptr () -> IO ()

type WidgetDragLeaveCallback = DragContext -> Word32 -> IO ()

data WidgetDragLeaveSignalInfo

Instances

SignalInfo WidgetDragLeaveSignalInfo

Associated Types

type HaskellCallbackType WidgetDragLeaveSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragLeaveSignalInfo -> o -> HaskellCallbackType WidgetDragLeaveSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragLeaveSignalInfo

type HaskellCallbackType WidgetDragLeaveSignalInfo = WidgetDragLeaveCallback

afterWidgetDragLeave :: (GObject a, MonadIO m) => a -> WidgetDragLeaveCallback -> m SignalHandlerId

genClosure_WidgetDragLeave :: WidgetDragLeaveCallback -> IO Closure

mk_WidgetDragLeaveCallback :: C_WidgetDragLeaveCallback -> IO (FunPtr C_WidgetDragLeaveCallback)

noWidgetDragLeaveCallback :: Maybe WidgetDragLeaveCallback

onWidgetDragLeave :: (GObject a, MonadIO m) => a -> WidgetDragLeaveCallback -> m SignalHandlerId

wrap_WidgetDragLeaveCallback :: WidgetDragLeaveCallback -> Ptr () -> Ptr DragContext -> Word32 -> Ptr () -> IO ()

dragMotion

type C_WidgetDragMotionCallback = Ptr () -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> Ptr () -> IO CInt

type WidgetDragMotionCallback = DragContext -> Int32 -> Int32 -> Word32 -> IO Bool

data WidgetDragMotionSignalInfo

Instances

SignalInfo WidgetDragMotionSignalInfo

Associated Types

type HaskellCallbackType WidgetDragMotionSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDragMotionSignalInfo -> o -> HaskellCallbackType WidgetDragMotionSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDragMotionSignalInfo

type HaskellCallbackType WidgetDragMotionSignalInfo = WidgetDragMotionCallback

afterWidgetDragMotion :: (GObject a, MonadIO m) => a -> WidgetDragMotionCallback -> m SignalHandlerId

genClosure_WidgetDragMotion :: WidgetDragMotionCallback -> IO Closure

mk_WidgetDragMotionCallback :: C_WidgetDragMotionCallback -> IO (FunPtr C_WidgetDragMotionCallback)

noWidgetDragMotionCallback :: Maybe WidgetDragMotionCallback

onWidgetDragMotion :: (GObject a, MonadIO m) => a -> WidgetDragMotionCallback -> m SignalHandlerId

wrap_WidgetDragMotionCallback :: WidgetDragMotionCallback -> Ptr () -> Ptr DragContext -> Int32 -> Int32 -> Word32 -> Ptr () -> IO CInt

draw

type C_WidgetDrawCallback = Ptr () -> Ptr Context -> Ptr () -> IO CInt

type WidgetDrawCallback = Context -> IO Bool

data WidgetDrawSignalInfo

Instances

SignalInfo WidgetDrawSignalInfo

Associated Types

type HaskellCallbackType WidgetDrawSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetDrawSignalInfo -> o -> HaskellCallbackType WidgetDrawSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetDrawSignalInfo

type HaskellCallbackType WidgetDrawSignalInfo = WidgetDrawCallback

afterWidgetDraw :: (GObject a, MonadIO m) => a -> WidgetDrawCallback -> m SignalHandlerId

genClosure_WidgetDraw :: WidgetDrawCallback -> IO Closure

mk_WidgetDrawCallback :: C_WidgetDrawCallback -> IO (FunPtr C_WidgetDrawCallback)

noWidgetDrawCallback :: Maybe WidgetDrawCallback

onWidgetDraw :: (GObject a, MonadIO m) => a -> WidgetDrawCallback -> m SignalHandlerId

wrap_WidgetDrawCallback :: WidgetDrawCallback -> Ptr () -> Ptr Context -> Ptr () -> IO CInt

enterNotifyEvent

type C_WidgetEnterNotifyEventCallback = Ptr () -> Ptr EventCrossing -> Ptr () -> IO CInt

type WidgetEnterNotifyEventCallback = EventCrossing -> IO Bool

data WidgetEnterNotifyEventSignalInfo

Instances

SignalInfo WidgetEnterNotifyEventSignalInfo

Associated Types

type HaskellCallbackType WidgetEnterNotifyEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetEnterNotifyEventSignalInfo -> o -> HaskellCallbackType WidgetEnterNotifyEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetEnterNotifyEventSignalInfo

type HaskellCallbackType WidgetEnterNotifyEventSignalInfo = WidgetEnterNotifyEventCallback

afterWidgetEnterNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetEnterNotifyEventCallback -> m SignalHandlerId

genClosure_WidgetEnterNotifyEvent :: WidgetEnterNotifyEventCallback -> IO Closure

mk_WidgetEnterNotifyEventCallback :: C_WidgetEnterNotifyEventCallback -> IO (FunPtr C_WidgetEnterNotifyEventCallback)

noWidgetEnterNotifyEventCallback :: Maybe WidgetEnterNotifyEventCallback

onWidgetEnterNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetEnterNotifyEventCallback -> m SignalHandlerId

wrap_WidgetEnterNotifyEventCallback :: WidgetEnterNotifyEventCallback -> Ptr () -> Ptr EventCrossing -> Ptr () -> IO CInt

event

type C_WidgetEventCallback = Ptr () -> Ptr Event -> Ptr () -> IO CInt

type WidgetEventCallback = Event -> IO Bool

data WidgetEventSignalInfo

Instances

SignalInfo WidgetEventSignalInfo

Associated Types

type HaskellCallbackType WidgetEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetEventSignalInfo -> o -> HaskellCallbackType WidgetEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetEventSignalInfo

type HaskellCallbackType WidgetEventSignalInfo = WidgetEventCallback

afterWidgetEvent :: (GObject a, MonadIO m) => a -> WidgetEventCallback -> m SignalHandlerId

genClosure_WidgetEvent :: WidgetEventCallback -> IO Closure

mk_WidgetEventCallback :: C_WidgetEventCallback -> IO (FunPtr C_WidgetEventCallback)

noWidgetEventCallback :: Maybe WidgetEventCallback

onWidgetEvent :: (GObject a, MonadIO m) => a -> WidgetEventCallback -> m SignalHandlerId

wrap_WidgetEventCallback :: WidgetEventCallback -> Ptr () -> Ptr Event -> Ptr () -> IO CInt

eventAfter

type C_WidgetEventAfterCallback = Ptr () -> Ptr Event -> Ptr () -> IO ()

type WidgetEventAfterCallback = Event -> IO ()

data WidgetEventAfterSignalInfo

Instances

SignalInfo WidgetEventAfterSignalInfo

Associated Types

type HaskellCallbackType WidgetEventAfterSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetEventAfterSignalInfo -> o -> HaskellCallbackType WidgetEventAfterSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetEventAfterSignalInfo

type HaskellCallbackType WidgetEventAfterSignalInfo = WidgetEventAfterCallback

afterWidgetEventAfter :: (GObject a, MonadIO m) => a -> WidgetEventAfterCallback -> m SignalHandlerId

genClosure_WidgetEventAfter :: WidgetEventAfterCallback -> IO Closure

mk_WidgetEventAfterCallback :: C_WidgetEventAfterCallback -> IO (FunPtr C_WidgetEventAfterCallback)

noWidgetEventAfterCallback :: Maybe WidgetEventAfterCallback

onWidgetEventAfter :: (GObject a, MonadIO m) => a -> WidgetEventAfterCallback -> m SignalHandlerId

wrap_WidgetEventAfterCallback :: WidgetEventAfterCallback -> Ptr () -> Ptr Event -> Ptr () -> IO ()

focus

type C_WidgetFocusCallback = Ptr () -> CUInt -> Ptr () -> IO CInt

type WidgetFocusCallback = DirectionType -> IO Bool

data WidgetFocusSignalInfo

Instances

SignalInfo WidgetFocusSignalInfo

Associated Types

type HaskellCallbackType WidgetFocusSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetFocusSignalInfo -> o -> HaskellCallbackType WidgetFocusSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetFocusSignalInfo

type HaskellCallbackType WidgetFocusSignalInfo = WidgetFocusCallback

afterWidgetFocus :: (GObject a, MonadIO m) => a -> WidgetFocusCallback -> m SignalHandlerId

genClosure_WidgetFocus :: WidgetFocusCallback -> IO Closure

mk_WidgetFocusCallback :: C_WidgetFocusCallback -> IO (FunPtr C_WidgetFocusCallback)

noWidgetFocusCallback :: Maybe WidgetFocusCallback

onWidgetFocus :: (GObject a, MonadIO m) => a -> WidgetFocusCallback -> m SignalHandlerId

wrap_WidgetFocusCallback :: WidgetFocusCallback -> Ptr () -> CUInt -> Ptr () -> IO CInt

focusInEvent

type C_WidgetFocusInEventCallback = Ptr () -> Ptr EventFocus -> Ptr () -> IO CInt

type WidgetFocusInEventCallback = EventFocus -> IO Bool

data WidgetFocusInEventSignalInfo

Instances

SignalInfo WidgetFocusInEventSignalInfo

Associated Types

type HaskellCallbackType WidgetFocusInEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetFocusInEventSignalInfo -> o -> HaskellCallbackType WidgetFocusInEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetFocusInEventSignalInfo

type HaskellCallbackType WidgetFocusInEventSignalInfo = WidgetFocusInEventCallback

afterWidgetFocusInEvent :: (GObject a, MonadIO m) => a -> WidgetFocusInEventCallback -> m SignalHandlerId

genClosure_WidgetFocusInEvent :: WidgetFocusInEventCallback -> IO Closure

mk_WidgetFocusInEventCallback :: C_WidgetFocusInEventCallback -> IO (FunPtr C_WidgetFocusInEventCallback)

noWidgetFocusInEventCallback :: Maybe WidgetFocusInEventCallback

onWidgetFocusInEvent :: (GObject a, MonadIO m) => a -> WidgetFocusInEventCallback -> m SignalHandlerId

wrap_WidgetFocusInEventCallback :: WidgetFocusInEventCallback -> Ptr () -> Ptr EventFocus -> Ptr () -> IO CInt

focusOutEvent

type C_WidgetFocusOutEventCallback = Ptr () -> Ptr EventFocus -> Ptr () -> IO CInt

type WidgetFocusOutEventCallback = EventFocus -> IO Bool

data WidgetFocusOutEventSignalInfo

Instances

SignalInfo WidgetFocusOutEventSignalInfo

Associated Types

type HaskellCallbackType WidgetFocusOutEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetFocusOutEventSignalInfo -> o -> HaskellCallbackType WidgetFocusOutEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetFocusOutEventSignalInfo

type HaskellCallbackType WidgetFocusOutEventSignalInfo = WidgetFocusOutEventCallback

afterWidgetFocusOutEvent :: (GObject a, MonadIO m) => a -> WidgetFocusOutEventCallback -> m SignalHandlerId

genClosure_WidgetFocusOutEvent :: WidgetFocusOutEventCallback -> IO Closure

mk_WidgetFocusOutEventCallback :: C_WidgetFocusOutEventCallback -> IO (FunPtr C_WidgetFocusOutEventCallback)

noWidgetFocusOutEventCallback :: Maybe WidgetFocusOutEventCallback

onWidgetFocusOutEvent :: (GObject a, MonadIO m) => a -> WidgetFocusOutEventCallback -> m SignalHandlerId

wrap_WidgetFocusOutEventCallback :: WidgetFocusOutEventCallback -> Ptr () -> Ptr EventFocus -> Ptr () -> IO CInt

grabBrokenEvent

type C_WidgetGrabBrokenEventCallback = Ptr () -> Ptr EventGrabBroken -> Ptr () -> IO CInt

type WidgetGrabBrokenEventCallback = EventGrabBroken -> IO Bool

data WidgetGrabBrokenEventSignalInfo

Instances

SignalInfo WidgetGrabBrokenEventSignalInfo

Associated Types

type HaskellCallbackType WidgetGrabBrokenEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetGrabBrokenEventSignalInfo -> o -> HaskellCallbackType WidgetGrabBrokenEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetGrabBrokenEventSignalInfo

type HaskellCallbackType WidgetGrabBrokenEventSignalInfo = WidgetGrabBrokenEventCallback

afterWidgetGrabBrokenEvent :: (GObject a, MonadIO m) => a -> WidgetGrabBrokenEventCallback -> m SignalHandlerId

genClosure_WidgetGrabBrokenEvent :: WidgetGrabBrokenEventCallback -> IO Closure

mk_WidgetGrabBrokenEventCallback :: C_WidgetGrabBrokenEventCallback -> IO (FunPtr C_WidgetGrabBrokenEventCallback)

noWidgetGrabBrokenEventCallback :: Maybe WidgetGrabBrokenEventCallback

onWidgetGrabBrokenEvent :: (GObject a, MonadIO m) => a -> WidgetGrabBrokenEventCallback -> m SignalHandlerId

wrap_WidgetGrabBrokenEventCallback :: WidgetGrabBrokenEventCallback -> Ptr () -> Ptr EventGrabBroken -> Ptr () -> IO CInt

grabFocus

type C_WidgetGrabFocusCallback = Ptr () -> Ptr () -> IO ()

type WidgetGrabFocusCallback = IO ()

data WidgetGrabFocusSignalInfo

Instances

SignalInfo WidgetGrabFocusSignalInfo

Associated Types

type HaskellCallbackType WidgetGrabFocusSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetGrabFocusSignalInfo -> o -> HaskellCallbackType WidgetGrabFocusSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetGrabFocusSignalInfo

type HaskellCallbackType WidgetGrabFocusSignalInfo = WidgetGrabFocusCallback

afterWidgetGrabFocus :: (GObject a, MonadIO m) => a -> WidgetGrabFocusCallback -> m SignalHandlerId

genClosure_WidgetGrabFocus :: WidgetGrabFocusCallback -> IO Closure

mk_WidgetGrabFocusCallback :: C_WidgetGrabFocusCallback -> IO (FunPtr C_WidgetGrabFocusCallback)

noWidgetGrabFocusCallback :: Maybe WidgetGrabFocusCallback

onWidgetGrabFocus :: (GObject a, MonadIO m) => a -> WidgetGrabFocusCallback -> m SignalHandlerId

wrap_WidgetGrabFocusCallback :: WidgetGrabFocusCallback -> Ptr () -> Ptr () -> IO ()

grabNotify

type C_WidgetGrabNotifyCallback = Ptr () -> CInt -> Ptr () -> IO ()

type WidgetGrabNotifyCallback = Bool -> IO ()

data WidgetGrabNotifySignalInfo

Instances

SignalInfo WidgetGrabNotifySignalInfo

Associated Types

type HaskellCallbackType WidgetGrabNotifySignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetGrabNotifySignalInfo -> o -> HaskellCallbackType WidgetGrabNotifySignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetGrabNotifySignalInfo

type HaskellCallbackType WidgetGrabNotifySignalInfo = WidgetGrabNotifyCallback

afterWidgetGrabNotify :: (GObject a, MonadIO m) => a -> WidgetGrabNotifyCallback -> m SignalHandlerId

genClosure_WidgetGrabNotify :: WidgetGrabNotifyCallback -> IO Closure

mk_WidgetGrabNotifyCallback :: C_WidgetGrabNotifyCallback -> IO (FunPtr C_WidgetGrabNotifyCallback)

noWidgetGrabNotifyCallback :: Maybe WidgetGrabNotifyCallback

onWidgetGrabNotify :: (GObject a, MonadIO m) => a -> WidgetGrabNotifyCallback -> m SignalHandlerId

wrap_WidgetGrabNotifyCallback :: WidgetGrabNotifyCallback -> Ptr () -> CInt -> Ptr () -> IO ()

hide

type C_WidgetHideCallback = Ptr () -> Ptr () -> IO ()

type WidgetHideCallback = IO ()

data WidgetHideSignalInfo

Instances

SignalInfo WidgetHideSignalInfo

Associated Types

type HaskellCallbackType WidgetHideSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetHideSignalInfo -> o -> HaskellCallbackType WidgetHideSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetHideSignalInfo

type HaskellCallbackType WidgetHideSignalInfo = WidgetHideCallback

afterWidgetHide :: (GObject a, MonadIO m) => a -> WidgetHideCallback -> m SignalHandlerId

genClosure_WidgetHide :: WidgetHideCallback -> IO Closure

mk_WidgetHideCallback :: C_WidgetHideCallback -> IO (FunPtr C_WidgetHideCallback)

noWidgetHideCallback :: Maybe WidgetHideCallback

onWidgetHide :: (GObject a, MonadIO m) => a -> WidgetHideCallback -> m SignalHandlerId

wrap_WidgetHideCallback :: WidgetHideCallback -> Ptr () -> Ptr () -> IO ()

hierarchyChanged

type C_WidgetHierarchyChangedCallback = Ptr () -> Ptr Widget -> Ptr () -> IO ()

type WidgetHierarchyChangedCallback = Maybe Widget -> IO ()

data WidgetHierarchyChangedSignalInfo

Instances

SignalInfo WidgetHierarchyChangedSignalInfo

Associated Types

type HaskellCallbackType WidgetHierarchyChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetHierarchyChangedSignalInfo -> o -> HaskellCallbackType WidgetHierarchyChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetHierarchyChangedSignalInfo

type HaskellCallbackType WidgetHierarchyChangedSignalInfo = WidgetHierarchyChangedCallback

afterWidgetHierarchyChanged :: (GObject a, MonadIO m) => a -> WidgetHierarchyChangedCallback -> m SignalHandlerId

genClosure_WidgetHierarchyChanged :: WidgetHierarchyChangedCallback -> IO Closure

mk_WidgetHierarchyChangedCallback :: C_WidgetHierarchyChangedCallback -> IO (FunPtr C_WidgetHierarchyChangedCallback)

noWidgetHierarchyChangedCallback :: Maybe WidgetHierarchyChangedCallback

onWidgetHierarchyChanged :: (GObject a, MonadIO m) => a -> WidgetHierarchyChangedCallback -> m SignalHandlerId

wrap_WidgetHierarchyChangedCallback :: WidgetHierarchyChangedCallback -> Ptr () -> Ptr Widget -> Ptr () -> IO ()

keyPressEvent

type C_WidgetKeyPressEventCallback = Ptr () -> Ptr EventKey -> Ptr () -> IO CInt

type WidgetKeyPressEventCallback = EventKey -> IO Bool

data WidgetKeyPressEventSignalInfo

Instances

SignalInfo WidgetKeyPressEventSignalInfo

Associated Types

type HaskellCallbackType WidgetKeyPressEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetKeyPressEventSignalInfo -> o -> HaskellCallbackType WidgetKeyPressEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetKeyPressEventSignalInfo

type HaskellCallbackType WidgetKeyPressEventSignalInfo = WidgetKeyPressEventCallback

afterWidgetKeyPressEvent :: (GObject a, MonadIO m) => a -> WidgetKeyPressEventCallback -> m SignalHandlerId

genClosure_WidgetKeyPressEvent :: WidgetKeyPressEventCallback -> IO Closure

mk_WidgetKeyPressEventCallback :: C_WidgetKeyPressEventCallback -> IO (FunPtr C_WidgetKeyPressEventCallback)

noWidgetKeyPressEventCallback :: Maybe WidgetKeyPressEventCallback

onWidgetKeyPressEvent :: (GObject a, MonadIO m) => a -> WidgetKeyPressEventCallback -> m SignalHandlerId

wrap_WidgetKeyPressEventCallback :: WidgetKeyPressEventCallback -> Ptr () -> Ptr EventKey -> Ptr () -> IO CInt

keyReleaseEvent

type C_WidgetKeyReleaseEventCallback = Ptr () -> Ptr EventKey -> Ptr () -> IO CInt

type WidgetKeyReleaseEventCallback = EventKey -> IO Bool

data WidgetKeyReleaseEventSignalInfo

Instances

SignalInfo WidgetKeyReleaseEventSignalInfo

Associated Types

type HaskellCallbackType WidgetKeyReleaseEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetKeyReleaseEventSignalInfo -> o -> HaskellCallbackType WidgetKeyReleaseEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetKeyReleaseEventSignalInfo

type HaskellCallbackType WidgetKeyReleaseEventSignalInfo = WidgetKeyReleaseEventCallback

afterWidgetKeyReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetKeyReleaseEventCallback -> m SignalHandlerId

genClosure_WidgetKeyReleaseEvent :: WidgetKeyReleaseEventCallback -> IO Closure

mk_WidgetKeyReleaseEventCallback :: C_WidgetKeyReleaseEventCallback -> IO (FunPtr C_WidgetKeyReleaseEventCallback)

noWidgetKeyReleaseEventCallback :: Maybe WidgetKeyReleaseEventCallback

onWidgetKeyReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetKeyReleaseEventCallback -> m SignalHandlerId

wrap_WidgetKeyReleaseEventCallback :: WidgetKeyReleaseEventCallback -> Ptr () -> Ptr EventKey -> Ptr () -> IO CInt

keynavFailed

type C_WidgetKeynavFailedCallback = Ptr () -> CUInt -> Ptr () -> IO CInt

type WidgetKeynavFailedCallback = DirectionType -> IO Bool

data WidgetKeynavFailedSignalInfo

Instances

SignalInfo WidgetKeynavFailedSignalInfo

Associated Types

type HaskellCallbackType WidgetKeynavFailedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetKeynavFailedSignalInfo -> o -> HaskellCallbackType WidgetKeynavFailedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetKeynavFailedSignalInfo

type HaskellCallbackType WidgetKeynavFailedSignalInfo = WidgetKeynavFailedCallback

afterWidgetKeynavFailed :: (GObject a, MonadIO m) => a -> WidgetKeynavFailedCallback -> m SignalHandlerId

genClosure_WidgetKeynavFailed :: WidgetKeynavFailedCallback -> IO Closure

mk_WidgetKeynavFailedCallback :: C_WidgetKeynavFailedCallback -> IO (FunPtr C_WidgetKeynavFailedCallback)

noWidgetKeynavFailedCallback :: Maybe WidgetKeynavFailedCallback

onWidgetKeynavFailed :: (GObject a, MonadIO m) => a -> WidgetKeynavFailedCallback -> m SignalHandlerId

wrap_WidgetKeynavFailedCallback :: WidgetKeynavFailedCallback -> Ptr () -> CUInt -> Ptr () -> IO CInt

leaveNotifyEvent

type C_WidgetLeaveNotifyEventCallback = Ptr () -> Ptr EventCrossing -> Ptr () -> IO CInt

type WidgetLeaveNotifyEventCallback = EventCrossing -> IO Bool

data WidgetLeaveNotifyEventSignalInfo

Instances

SignalInfo WidgetLeaveNotifyEventSignalInfo

Associated Types

type HaskellCallbackType WidgetLeaveNotifyEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetLeaveNotifyEventSignalInfo -> o -> HaskellCallbackType WidgetLeaveNotifyEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetLeaveNotifyEventSignalInfo

type HaskellCallbackType WidgetLeaveNotifyEventSignalInfo = WidgetLeaveNotifyEventCallback

afterWidgetLeaveNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetLeaveNotifyEventCallback -> m SignalHandlerId

genClosure_WidgetLeaveNotifyEvent :: WidgetLeaveNotifyEventCallback -> IO Closure

mk_WidgetLeaveNotifyEventCallback :: C_WidgetLeaveNotifyEventCallback -> IO (FunPtr C_WidgetLeaveNotifyEventCallback)

noWidgetLeaveNotifyEventCallback :: Maybe WidgetLeaveNotifyEventCallback

onWidgetLeaveNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetLeaveNotifyEventCallback -> m SignalHandlerId

wrap_WidgetLeaveNotifyEventCallback :: WidgetLeaveNotifyEventCallback -> Ptr () -> Ptr EventCrossing -> Ptr () -> IO CInt

map

type C_WidgetMapCallback = Ptr () -> Ptr () -> IO ()

type WidgetMapCallback = IO ()

data WidgetMapSignalInfo

Instances

SignalInfo WidgetMapSignalInfo

Associated Types

type HaskellCallbackType WidgetMapSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetMapSignalInfo -> o -> HaskellCallbackType WidgetMapSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetMapSignalInfo

type HaskellCallbackType WidgetMapSignalInfo = WidgetMapCallback

afterWidgetMap :: (GObject a, MonadIO m) => a -> WidgetMapCallback -> m SignalHandlerId

genClosure_WidgetMap :: WidgetMapCallback -> IO Closure

mk_WidgetMapCallback :: C_WidgetMapCallback -> IO (FunPtr C_WidgetMapCallback)

noWidgetMapCallback :: Maybe WidgetMapCallback

onWidgetMap :: (GObject a, MonadIO m) => a -> WidgetMapCallback -> m SignalHandlerId

wrap_WidgetMapCallback :: WidgetMapCallback -> Ptr () -> Ptr () -> IO ()

mapEvent

type C_WidgetMapEventCallback = Ptr () -> Ptr EventAny -> Ptr () -> IO CInt

type WidgetMapEventCallback = EventAny -> IO Bool

data WidgetMapEventSignalInfo

Instances

SignalInfo WidgetMapEventSignalInfo

Associated Types

type HaskellCallbackType WidgetMapEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetMapEventSignalInfo -> o -> HaskellCallbackType WidgetMapEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetMapEventSignalInfo

type HaskellCallbackType WidgetMapEventSignalInfo = WidgetMapEventCallback

afterWidgetMapEvent :: (GObject a, MonadIO m) => a -> WidgetMapEventCallback -> m SignalHandlerId

genClosure_WidgetMapEvent :: WidgetMapEventCallback -> IO Closure

mk_WidgetMapEventCallback :: C_WidgetMapEventCallback -> IO (FunPtr C_WidgetMapEventCallback)

noWidgetMapEventCallback :: Maybe WidgetMapEventCallback

onWidgetMapEvent :: (GObject a, MonadIO m) => a -> WidgetMapEventCallback -> m SignalHandlerId

wrap_WidgetMapEventCallback :: WidgetMapEventCallback -> Ptr () -> Ptr EventAny -> Ptr () -> IO CInt

mnemonicActivate

type C_WidgetMnemonicActivateCallback = Ptr () -> CInt -> Ptr () -> IO CInt

type WidgetMnemonicActivateCallback = Bool -> IO Bool

data WidgetMnemonicActivateSignalInfo

Instances

SignalInfo WidgetMnemonicActivateSignalInfo

Associated Types

type HaskellCallbackType WidgetMnemonicActivateSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetMnemonicActivateSignalInfo -> o -> HaskellCallbackType WidgetMnemonicActivateSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetMnemonicActivateSignalInfo

type HaskellCallbackType WidgetMnemonicActivateSignalInfo = WidgetMnemonicActivateCallback

afterWidgetMnemonicActivate :: (GObject a, MonadIO m) => a -> WidgetMnemonicActivateCallback -> m SignalHandlerId

genClosure_WidgetMnemonicActivate :: WidgetMnemonicActivateCallback -> IO Closure

mk_WidgetMnemonicActivateCallback :: C_WidgetMnemonicActivateCallback -> IO (FunPtr C_WidgetMnemonicActivateCallback)

noWidgetMnemonicActivateCallback :: Maybe WidgetMnemonicActivateCallback

onWidgetMnemonicActivate :: (GObject a, MonadIO m) => a -> WidgetMnemonicActivateCallback -> m SignalHandlerId

wrap_WidgetMnemonicActivateCallback :: WidgetMnemonicActivateCallback -> Ptr () -> CInt -> Ptr () -> IO CInt

motionNotifyEvent

type C_WidgetMotionNotifyEventCallback = Ptr () -> Ptr EventMotion -> Ptr () -> IO CInt

type WidgetMotionNotifyEventCallback = EventMotion -> IO Bool

data WidgetMotionNotifyEventSignalInfo

Instances

SignalInfo WidgetMotionNotifyEventSignalInfo

Associated Types

type HaskellCallbackType WidgetMotionNotifyEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetMotionNotifyEventSignalInfo -> o -> HaskellCallbackType WidgetMotionNotifyEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetMotionNotifyEventSignalInfo

type HaskellCallbackType WidgetMotionNotifyEventSignalInfo = WidgetMotionNotifyEventCallback

afterWidgetMotionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetMotionNotifyEventCallback -> m SignalHandlerId

genClosure_WidgetMotionNotifyEvent :: WidgetMotionNotifyEventCallback -> IO Closure

mk_WidgetMotionNotifyEventCallback :: C_WidgetMotionNotifyEventCallback -> IO (FunPtr C_WidgetMotionNotifyEventCallback)

noWidgetMotionNotifyEventCallback :: Maybe WidgetMotionNotifyEventCallback

onWidgetMotionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetMotionNotifyEventCallback -> m SignalHandlerId

wrap_WidgetMotionNotifyEventCallback :: WidgetMotionNotifyEventCallback -> Ptr () -> Ptr EventMotion -> Ptr () -> IO CInt

moveFocus

type C_WidgetMoveFocusCallback = Ptr () -> CUInt -> Ptr () -> IO ()

type WidgetMoveFocusCallback = DirectionType -> IO ()

data WidgetMoveFocusSignalInfo

Instances

SignalInfo WidgetMoveFocusSignalInfo

Associated Types

type HaskellCallbackType WidgetMoveFocusSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetMoveFocusSignalInfo -> o -> HaskellCallbackType WidgetMoveFocusSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetMoveFocusSignalInfo

type HaskellCallbackType WidgetMoveFocusSignalInfo = WidgetMoveFocusCallback

afterWidgetMoveFocus :: (GObject a, MonadIO m) => a -> WidgetMoveFocusCallback -> m SignalHandlerId

genClosure_WidgetMoveFocus :: WidgetMoveFocusCallback -> IO Closure

mk_WidgetMoveFocusCallback :: C_WidgetMoveFocusCallback -> IO (FunPtr C_WidgetMoveFocusCallback)

noWidgetMoveFocusCallback :: Maybe WidgetMoveFocusCallback

onWidgetMoveFocus :: (GObject a, MonadIO m) => a -> WidgetMoveFocusCallback -> m SignalHandlerId

wrap_WidgetMoveFocusCallback :: WidgetMoveFocusCallback -> Ptr () -> CUInt -> Ptr () -> IO ()

parentSet

type C_WidgetParentSetCallback = Ptr () -> Ptr Widget -> Ptr () -> IO ()

type WidgetParentSetCallback = Maybe Widget -> IO ()

data WidgetParentSetSignalInfo

Instances

SignalInfo WidgetParentSetSignalInfo

Associated Types

type HaskellCallbackType WidgetParentSetSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetParentSetSignalInfo -> o -> HaskellCallbackType WidgetParentSetSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetParentSetSignalInfo

type HaskellCallbackType WidgetParentSetSignalInfo = WidgetParentSetCallback

afterWidgetParentSet :: (GObject a, MonadIO m) => a -> WidgetParentSetCallback -> m SignalHandlerId

genClosure_WidgetParentSet :: WidgetParentSetCallback -> IO Closure

mk_WidgetParentSetCallback :: C_WidgetParentSetCallback -> IO (FunPtr C_WidgetParentSetCallback)

noWidgetParentSetCallback :: Maybe WidgetParentSetCallback

onWidgetParentSet :: (GObject a, MonadIO m) => a -> WidgetParentSetCallback -> m SignalHandlerId

wrap_WidgetParentSetCallback :: WidgetParentSetCallback -> Ptr () -> Ptr Widget -> Ptr () -> IO ()

popupMenu

type C_WidgetPopupMenuCallback = Ptr () -> Ptr () -> IO CInt

type WidgetPopupMenuCallback = IO Bool

data WidgetPopupMenuSignalInfo

Instances

SignalInfo WidgetPopupMenuSignalInfo

Associated Types

type HaskellCallbackType WidgetPopupMenuSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetPopupMenuSignalInfo -> o -> HaskellCallbackType WidgetPopupMenuSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetPopupMenuSignalInfo

type HaskellCallbackType WidgetPopupMenuSignalInfo = WidgetPopupMenuCallback

afterWidgetPopupMenu :: (GObject a, MonadIO m) => a -> WidgetPopupMenuCallback -> m SignalHandlerId

genClosure_WidgetPopupMenu :: WidgetPopupMenuCallback -> IO Closure

mk_WidgetPopupMenuCallback :: C_WidgetPopupMenuCallback -> IO (FunPtr C_WidgetPopupMenuCallback)

noWidgetPopupMenuCallback :: Maybe WidgetPopupMenuCallback

onWidgetPopupMenu :: (GObject a, MonadIO m) => a -> WidgetPopupMenuCallback -> m SignalHandlerId

wrap_WidgetPopupMenuCallback :: WidgetPopupMenuCallback -> Ptr () -> Ptr () -> IO CInt

propertyNotifyEvent

type C_WidgetPropertyNotifyEventCallback = Ptr () -> Ptr EventProperty -> Ptr () -> IO CInt

type WidgetPropertyNotifyEventCallback = EventProperty -> IO Bool

data WidgetPropertyNotifyEventSignalInfo

Instances

SignalInfo WidgetPropertyNotifyEventSignalInfo

Associated Types

type HaskellCallbackType WidgetPropertyNotifyEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetPropertyNotifyEventSignalInfo -> o -> HaskellCallbackType WidgetPropertyNotifyEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetPropertyNotifyEventSignalInfo

type HaskellCallbackType WidgetPropertyNotifyEventSignalInfo = WidgetPropertyNotifyEventCallback

afterWidgetPropertyNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetPropertyNotifyEventCallback -> m SignalHandlerId

genClosure_WidgetPropertyNotifyEvent :: WidgetPropertyNotifyEventCallback -> IO Closure

mk_WidgetPropertyNotifyEventCallback :: C_WidgetPropertyNotifyEventCallback -> IO (FunPtr C_WidgetPropertyNotifyEventCallback)

noWidgetPropertyNotifyEventCallback :: Maybe WidgetPropertyNotifyEventCallback

onWidgetPropertyNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetPropertyNotifyEventCallback -> m SignalHandlerId

wrap_WidgetPropertyNotifyEventCallback :: WidgetPropertyNotifyEventCallback -> Ptr () -> Ptr EventProperty -> Ptr () -> IO CInt

proximityInEvent

type C_WidgetProximityInEventCallback = Ptr () -> Ptr EventProximity -> Ptr () -> IO CInt

type WidgetProximityInEventCallback = EventProximity -> IO Bool

data WidgetProximityInEventSignalInfo

Instances

SignalInfo WidgetProximityInEventSignalInfo

Associated Types

type HaskellCallbackType WidgetProximityInEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetProximityInEventSignalInfo -> o -> HaskellCallbackType WidgetProximityInEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetProximityInEventSignalInfo

type HaskellCallbackType WidgetProximityInEventSignalInfo = WidgetProximityInEventCallback

afterWidgetProximityInEvent :: (GObject a, MonadIO m) => a -> WidgetProximityInEventCallback -> m SignalHandlerId

genClosure_WidgetProximityInEvent :: WidgetProximityInEventCallback -> IO Closure

mk_WidgetProximityInEventCallback :: C_WidgetProximityInEventCallback -> IO (FunPtr C_WidgetProximityInEventCallback)

noWidgetProximityInEventCallback :: Maybe WidgetProximityInEventCallback

onWidgetProximityInEvent :: (GObject a, MonadIO m) => a -> WidgetProximityInEventCallback -> m SignalHandlerId

wrap_WidgetProximityInEventCallback :: WidgetProximityInEventCallback -> Ptr () -> Ptr EventProximity -> Ptr () -> IO CInt

proximityOutEvent

type C_WidgetProximityOutEventCallback = Ptr () -> Ptr EventProximity -> Ptr () -> IO CInt

type WidgetProximityOutEventCallback = EventProximity -> IO Bool

data WidgetProximityOutEventSignalInfo

Instances

SignalInfo WidgetProximityOutEventSignalInfo

Associated Types

type HaskellCallbackType WidgetProximityOutEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetProximityOutEventSignalInfo -> o -> HaskellCallbackType WidgetProximityOutEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetProximityOutEventSignalInfo

type HaskellCallbackType WidgetProximityOutEventSignalInfo = WidgetProximityOutEventCallback

afterWidgetProximityOutEvent :: (GObject a, MonadIO m) => a -> WidgetProximityOutEventCallback -> m SignalHandlerId

genClosure_WidgetProximityOutEvent :: WidgetProximityOutEventCallback -> IO Closure

mk_WidgetProximityOutEventCallback :: C_WidgetProximityOutEventCallback -> IO (FunPtr C_WidgetProximityOutEventCallback)

noWidgetProximityOutEventCallback :: Maybe WidgetProximityOutEventCallback

onWidgetProximityOutEvent :: (GObject a, MonadIO m) => a -> WidgetProximityOutEventCallback -> m SignalHandlerId

wrap_WidgetProximityOutEventCallback :: WidgetProximityOutEventCallback -> Ptr () -> Ptr EventProximity -> Ptr () -> IO CInt

queryTooltip

type C_WidgetQueryTooltipCallback = Ptr () -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> Ptr () -> IO CInt

type WidgetQueryTooltipCallback = Int32 -> Int32 -> Bool -> Tooltip -> IO Bool

data WidgetQueryTooltipSignalInfo

Instances

SignalInfo WidgetQueryTooltipSignalInfo

Associated Types

type HaskellCallbackType WidgetQueryTooltipSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetQueryTooltipSignalInfo -> o -> HaskellCallbackType WidgetQueryTooltipSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetQueryTooltipSignalInfo

type HaskellCallbackType WidgetQueryTooltipSignalInfo = WidgetQueryTooltipCallback

afterWidgetQueryTooltip :: (GObject a, MonadIO m) => a -> WidgetQueryTooltipCallback -> m SignalHandlerId

genClosure_WidgetQueryTooltip :: WidgetQueryTooltipCallback -> IO Closure

mk_WidgetQueryTooltipCallback :: C_WidgetQueryTooltipCallback -> IO (FunPtr C_WidgetQueryTooltipCallback)

noWidgetQueryTooltipCallback :: Maybe WidgetQueryTooltipCallback

onWidgetQueryTooltip :: (GObject a, MonadIO m) => a -> WidgetQueryTooltipCallback -> m SignalHandlerId

wrap_WidgetQueryTooltipCallback :: WidgetQueryTooltipCallback -> Ptr () -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> Ptr () -> IO CInt

realize

type C_WidgetRealizeCallback = Ptr () -> Ptr () -> IO ()

type WidgetRealizeCallback = IO ()

data WidgetRealizeSignalInfo

Instances

SignalInfo WidgetRealizeSignalInfo

Associated Types

type HaskellCallbackType WidgetRealizeSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetRealizeSignalInfo -> o -> HaskellCallbackType WidgetRealizeSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetRealizeSignalInfo

type HaskellCallbackType WidgetRealizeSignalInfo = WidgetRealizeCallback

afterWidgetRealize :: (GObject a, MonadIO m) => a -> WidgetRealizeCallback -> m SignalHandlerId

genClosure_WidgetRealize :: WidgetRealizeCallback -> IO Closure

mk_WidgetRealizeCallback :: C_WidgetRealizeCallback -> IO (FunPtr C_WidgetRealizeCallback)

noWidgetRealizeCallback :: Maybe WidgetRealizeCallback

onWidgetRealize :: (GObject a, MonadIO m) => a -> WidgetRealizeCallback -> m SignalHandlerId

wrap_WidgetRealizeCallback :: WidgetRealizeCallback -> Ptr () -> Ptr () -> IO ()

screenChanged

type C_WidgetScreenChangedCallback = Ptr () -> Ptr Screen -> Ptr () -> IO ()

type WidgetScreenChangedCallback = Maybe Screen -> IO ()

data WidgetScreenChangedSignalInfo

Instances

SignalInfo WidgetScreenChangedSignalInfo

Associated Types

type HaskellCallbackType WidgetScreenChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetScreenChangedSignalInfo -> o -> HaskellCallbackType WidgetScreenChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetScreenChangedSignalInfo

type HaskellCallbackType WidgetScreenChangedSignalInfo = WidgetScreenChangedCallback

afterWidgetScreenChanged :: (GObject a, MonadIO m) => a -> WidgetScreenChangedCallback -> m SignalHandlerId

genClosure_WidgetScreenChanged :: WidgetScreenChangedCallback -> IO Closure

mk_WidgetScreenChangedCallback :: C_WidgetScreenChangedCallback -> IO (FunPtr C_WidgetScreenChangedCallback)

noWidgetScreenChangedCallback :: Maybe WidgetScreenChangedCallback

onWidgetScreenChanged :: (GObject a, MonadIO m) => a -> WidgetScreenChangedCallback -> m SignalHandlerId

wrap_WidgetScreenChangedCallback :: WidgetScreenChangedCallback -> Ptr () -> Ptr Screen -> Ptr () -> IO ()

scrollEvent

type C_WidgetScrollEventCallback = Ptr () -> Ptr EventScroll -> Ptr () -> IO CInt

type WidgetScrollEventCallback = EventScroll -> IO Bool

data WidgetScrollEventSignalInfo

Instances

SignalInfo WidgetScrollEventSignalInfo

Associated Types

type HaskellCallbackType WidgetScrollEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetScrollEventSignalInfo -> o -> HaskellCallbackType WidgetScrollEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetScrollEventSignalInfo

type HaskellCallbackType WidgetScrollEventSignalInfo = WidgetScrollEventCallback

afterWidgetScrollEvent :: (GObject a, MonadIO m) => a -> WidgetScrollEventCallback -> m SignalHandlerId

genClosure_WidgetScrollEvent :: WidgetScrollEventCallback -> IO Closure

mk_WidgetScrollEventCallback :: C_WidgetScrollEventCallback -> IO (FunPtr C_WidgetScrollEventCallback)

noWidgetScrollEventCallback :: Maybe WidgetScrollEventCallback

onWidgetScrollEvent :: (GObject a, MonadIO m) => a -> WidgetScrollEventCallback -> m SignalHandlerId

wrap_WidgetScrollEventCallback :: WidgetScrollEventCallback -> Ptr () -> Ptr EventScroll -> Ptr () -> IO CInt

selectionClearEvent

type C_WidgetSelectionClearEventCallback = Ptr () -> Ptr EventSelection -> Ptr () -> IO CInt

type WidgetSelectionClearEventCallback = EventSelection -> IO Bool

data WidgetSelectionClearEventSignalInfo

Instances

SignalInfo WidgetSelectionClearEventSignalInfo

Associated Types

type HaskellCallbackType WidgetSelectionClearEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetSelectionClearEventSignalInfo -> o -> HaskellCallbackType WidgetSelectionClearEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetSelectionClearEventSignalInfo

type HaskellCallbackType WidgetSelectionClearEventSignalInfo = WidgetSelectionClearEventCallback

afterWidgetSelectionClearEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionClearEventCallback -> m SignalHandlerId

genClosure_WidgetSelectionClearEvent :: WidgetSelectionClearEventCallback -> IO Closure

mk_WidgetSelectionClearEventCallback :: C_WidgetSelectionClearEventCallback -> IO (FunPtr C_WidgetSelectionClearEventCallback)

noWidgetSelectionClearEventCallback :: Maybe WidgetSelectionClearEventCallback

onWidgetSelectionClearEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionClearEventCallback -> m SignalHandlerId

wrap_WidgetSelectionClearEventCallback :: WidgetSelectionClearEventCallback -> Ptr () -> Ptr EventSelection -> Ptr () -> IO CInt

selectionGet

type C_WidgetSelectionGetCallback = Ptr () -> Ptr SelectionData -> Word32 -> Word32 -> Ptr () -> IO ()

type WidgetSelectionGetCallback = SelectionData -> Word32 -> Word32 -> IO ()

data WidgetSelectionGetSignalInfo

Instances

SignalInfo WidgetSelectionGetSignalInfo

Associated Types

type HaskellCallbackType WidgetSelectionGetSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetSelectionGetSignalInfo -> o -> HaskellCallbackType WidgetSelectionGetSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetSelectionGetSignalInfo

type HaskellCallbackType WidgetSelectionGetSignalInfo = WidgetSelectionGetCallback

afterWidgetSelectionGet :: (GObject a, MonadIO m) => a -> WidgetSelectionGetCallback -> m SignalHandlerId

genClosure_WidgetSelectionGet :: WidgetSelectionGetCallback -> IO Closure

mk_WidgetSelectionGetCallback :: C_WidgetSelectionGetCallback -> IO (FunPtr C_WidgetSelectionGetCallback)

noWidgetSelectionGetCallback :: Maybe WidgetSelectionGetCallback

onWidgetSelectionGet :: (GObject a, MonadIO m) => a -> WidgetSelectionGetCallback -> m SignalHandlerId

wrap_WidgetSelectionGetCallback :: WidgetSelectionGetCallback -> Ptr () -> Ptr SelectionData -> Word32 -> Word32 -> Ptr () -> IO ()

selectionNotifyEvent

type C_WidgetSelectionNotifyEventCallback = Ptr () -> Ptr EventSelection -> Ptr () -> IO CInt

type WidgetSelectionNotifyEventCallback = EventSelection -> IO Bool

data WidgetSelectionNotifyEventSignalInfo

Instances

SignalInfo WidgetSelectionNotifyEventSignalInfo

Associated Types

type HaskellCallbackType WidgetSelectionNotifyEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetSelectionNotifyEventSignalInfo -> o -> HaskellCallbackType WidgetSelectionNotifyEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetSelectionNotifyEventSignalInfo

type HaskellCallbackType WidgetSelectionNotifyEventSignalInfo = WidgetSelectionNotifyEventCallback

afterWidgetSelectionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionNotifyEventCallback -> m SignalHandlerId

genClosure_WidgetSelectionNotifyEvent :: WidgetSelectionNotifyEventCallback -> IO Closure

mk_WidgetSelectionNotifyEventCallback :: C_WidgetSelectionNotifyEventCallback -> IO (FunPtr C_WidgetSelectionNotifyEventCallback)

noWidgetSelectionNotifyEventCallback :: Maybe WidgetSelectionNotifyEventCallback

onWidgetSelectionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionNotifyEventCallback -> m SignalHandlerId

wrap_WidgetSelectionNotifyEventCallback :: WidgetSelectionNotifyEventCallback -> Ptr () -> Ptr EventSelection -> Ptr () -> IO CInt

selectionReceived

type C_WidgetSelectionReceivedCallback = Ptr () -> Ptr SelectionData -> Word32 -> Ptr () -> IO ()

type WidgetSelectionReceivedCallback = SelectionData -> Word32 -> IO ()

data WidgetSelectionReceivedSignalInfo

Instances

SignalInfo WidgetSelectionReceivedSignalInfo

Associated Types

type HaskellCallbackType WidgetSelectionReceivedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetSelectionReceivedSignalInfo -> o -> HaskellCallbackType WidgetSelectionReceivedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetSelectionReceivedSignalInfo

type HaskellCallbackType WidgetSelectionReceivedSignalInfo = WidgetSelectionReceivedCallback

afterWidgetSelectionReceived :: (GObject a, MonadIO m) => a -> WidgetSelectionReceivedCallback -> m SignalHandlerId

genClosure_WidgetSelectionReceived :: WidgetSelectionReceivedCallback -> IO Closure

mk_WidgetSelectionReceivedCallback :: C_WidgetSelectionReceivedCallback -> IO (FunPtr C_WidgetSelectionReceivedCallback)

noWidgetSelectionReceivedCallback :: Maybe WidgetSelectionReceivedCallback

onWidgetSelectionReceived :: (GObject a, MonadIO m) => a -> WidgetSelectionReceivedCallback -> m SignalHandlerId

wrap_WidgetSelectionReceivedCallback :: WidgetSelectionReceivedCallback -> Ptr () -> Ptr SelectionData -> Word32 -> Ptr () -> IO ()

selectionRequestEvent

type C_WidgetSelectionRequestEventCallback = Ptr () -> Ptr EventSelection -> Ptr () -> IO CInt

type WidgetSelectionRequestEventCallback = EventSelection -> IO Bool

data WidgetSelectionRequestEventSignalInfo

Instances

SignalInfo WidgetSelectionRequestEventSignalInfo

Associated Types

type HaskellCallbackType WidgetSelectionRequestEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetSelectionRequestEventSignalInfo -> o -> HaskellCallbackType WidgetSelectionRequestEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetSelectionRequestEventSignalInfo

type HaskellCallbackType WidgetSelectionRequestEventSignalInfo = WidgetSelectionRequestEventCallback

afterWidgetSelectionRequestEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionRequestEventCallback -> m SignalHandlerId

genClosure_WidgetSelectionRequestEvent :: WidgetSelectionRequestEventCallback -> IO Closure

mk_WidgetSelectionRequestEventCallback :: C_WidgetSelectionRequestEventCallback -> IO (FunPtr C_WidgetSelectionRequestEventCallback)

noWidgetSelectionRequestEventCallback :: Maybe WidgetSelectionRequestEventCallback

onWidgetSelectionRequestEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionRequestEventCallback -> m SignalHandlerId

wrap_WidgetSelectionRequestEventCallback :: WidgetSelectionRequestEventCallback -> Ptr () -> Ptr EventSelection -> Ptr () -> IO CInt

show

type C_WidgetShowCallback = Ptr () -> Ptr () -> IO ()

type WidgetShowCallback = IO ()

data WidgetShowSignalInfo

Instances

SignalInfo WidgetShowSignalInfo

Associated Types

type HaskellCallbackType WidgetShowSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetShowSignalInfo -> o -> HaskellCallbackType WidgetShowSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetShowSignalInfo

type HaskellCallbackType WidgetShowSignalInfo = WidgetShowCallback

afterWidgetShow :: (GObject a, MonadIO m) => a -> WidgetShowCallback -> m SignalHandlerId

genClosure_WidgetShow :: WidgetShowCallback -> IO Closure

mk_WidgetShowCallback :: C_WidgetShowCallback -> IO (FunPtr C_WidgetShowCallback)

noWidgetShowCallback :: Maybe WidgetShowCallback

onWidgetShow :: (GObject a, MonadIO m) => a -> WidgetShowCallback -> m SignalHandlerId

wrap_WidgetShowCallback :: WidgetShowCallback -> Ptr () -> Ptr () -> IO ()

showHelp

type C_WidgetShowHelpCallback = Ptr () -> CUInt -> Ptr () -> IO CInt

type WidgetShowHelpCallback = WidgetHelpType -> IO Bool

data WidgetShowHelpSignalInfo

Instances

SignalInfo WidgetShowHelpSignalInfo

Associated Types

type HaskellCallbackType WidgetShowHelpSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetShowHelpSignalInfo -> o -> HaskellCallbackType WidgetShowHelpSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetShowHelpSignalInfo

type HaskellCallbackType WidgetShowHelpSignalInfo = WidgetShowHelpCallback

afterWidgetShowHelp :: (GObject a, MonadIO m) => a -> WidgetShowHelpCallback -> m SignalHandlerId

genClosure_WidgetShowHelp :: WidgetShowHelpCallback -> IO Closure

mk_WidgetShowHelpCallback :: C_WidgetShowHelpCallback -> IO (FunPtr C_WidgetShowHelpCallback)

noWidgetShowHelpCallback :: Maybe WidgetShowHelpCallback

onWidgetShowHelp :: (GObject a, MonadIO m) => a -> WidgetShowHelpCallback -> m SignalHandlerId

wrap_WidgetShowHelpCallback :: WidgetShowHelpCallback -> Ptr () -> CUInt -> Ptr () -> IO CInt

sizeAllocate

type C_WidgetSizeAllocateCallback = Ptr () -> Ptr Rectangle -> Ptr () -> IO ()

type WidgetSizeAllocateCallback = Rectangle -> IO ()

data WidgetSizeAllocateSignalInfo

Instances

SignalInfo WidgetSizeAllocateSignalInfo

Associated Types

type HaskellCallbackType WidgetSizeAllocateSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetSizeAllocateSignalInfo -> o -> HaskellCallbackType WidgetSizeAllocateSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetSizeAllocateSignalInfo

type HaskellCallbackType WidgetSizeAllocateSignalInfo = WidgetSizeAllocateCallback

afterWidgetSizeAllocate :: (GObject a, MonadIO m) => a -> WidgetSizeAllocateCallback -> m SignalHandlerId

genClosure_WidgetSizeAllocate :: WidgetSizeAllocateCallback -> IO Closure

mk_WidgetSizeAllocateCallback :: C_WidgetSizeAllocateCallback -> IO (FunPtr C_WidgetSizeAllocateCallback)

noWidgetSizeAllocateCallback :: Maybe WidgetSizeAllocateCallback

onWidgetSizeAllocate :: (GObject a, MonadIO m) => a -> WidgetSizeAllocateCallback -> m SignalHandlerId

wrap_WidgetSizeAllocateCallback :: WidgetSizeAllocateCallback -> Ptr () -> Ptr Rectangle -> Ptr () -> IO ()

stateChanged

type C_WidgetStateChangedCallback = Ptr () -> CUInt -> Ptr () -> IO ()

type WidgetStateChangedCallback = StateType -> IO ()

Deprecated: (Since version 3.0)Use Widget::state-flags-changed instead.

data WidgetStateChangedSignalInfo

Instances

SignalInfo WidgetStateChangedSignalInfo

Associated Types

type HaskellCallbackType WidgetStateChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetStateChangedSignalInfo -> o -> HaskellCallbackType WidgetStateChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetStateChangedSignalInfo

type HaskellCallbackType WidgetStateChangedSignalInfo = WidgetStateChangedCallback

afterWidgetStateChanged :: (GObject a, MonadIO m) => a -> WidgetStateChangedCallback -> m SignalHandlerId

genClosure_WidgetStateChanged :: WidgetStateChangedCallback -> IO Closure

mk_WidgetStateChangedCallback :: C_WidgetStateChangedCallback -> IO (FunPtr C_WidgetStateChangedCallback)

noWidgetStateChangedCallback :: Maybe WidgetStateChangedCallback

onWidgetStateChanged :: (GObject a, MonadIO m) => a -> WidgetStateChangedCallback -> m SignalHandlerId

wrap_WidgetStateChangedCallback :: WidgetStateChangedCallback -> Ptr () -> CUInt -> Ptr () -> IO ()

stateFlagsChanged

type C_WidgetStateFlagsChangedCallback = Ptr () -> CUInt -> Ptr () -> IO ()

type WidgetStateFlagsChangedCallback = [StateFlags] -> IO ()

data WidgetStateFlagsChangedSignalInfo

Instances

SignalInfo WidgetStateFlagsChangedSignalInfo

Associated Types

type HaskellCallbackType WidgetStateFlagsChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetStateFlagsChangedSignalInfo -> o -> HaskellCallbackType WidgetStateFlagsChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetStateFlagsChangedSignalInfo

type HaskellCallbackType WidgetStateFlagsChangedSignalInfo = WidgetStateFlagsChangedCallback

afterWidgetStateFlagsChanged :: (GObject a, MonadIO m) => a -> WidgetStateFlagsChangedCallback -> m SignalHandlerId

genClosure_WidgetStateFlagsChanged :: WidgetStateFlagsChangedCallback -> IO Closure

mk_WidgetStateFlagsChangedCallback :: C_WidgetStateFlagsChangedCallback -> IO (FunPtr C_WidgetStateFlagsChangedCallback)

noWidgetStateFlagsChangedCallback :: Maybe WidgetStateFlagsChangedCallback

onWidgetStateFlagsChanged :: (GObject a, MonadIO m) => a -> WidgetStateFlagsChangedCallback -> m SignalHandlerId

wrap_WidgetStateFlagsChangedCallback :: WidgetStateFlagsChangedCallback -> Ptr () -> CUInt -> Ptr () -> IO ()

styleSet

type C_WidgetStyleSetCallback = Ptr () -> Ptr Style -> Ptr () -> IO ()

type WidgetStyleSetCallback = Maybe Style -> IO ()

Deprecated: (Since version 3.0)Use the Widget::style-updated signal

data WidgetStyleSetSignalInfo

Instances

SignalInfo WidgetStyleSetSignalInfo

Associated Types

type HaskellCallbackType WidgetStyleSetSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetStyleSetSignalInfo -> o -> HaskellCallbackType WidgetStyleSetSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetStyleSetSignalInfo

type HaskellCallbackType WidgetStyleSetSignalInfo = WidgetStyleSetCallback

afterWidgetStyleSet :: (GObject a, MonadIO m) => a -> WidgetStyleSetCallback -> m SignalHandlerId

genClosure_WidgetStyleSet :: WidgetStyleSetCallback -> IO Closure

mk_WidgetStyleSetCallback :: C_WidgetStyleSetCallback -> IO (FunPtr C_WidgetStyleSetCallback)

noWidgetStyleSetCallback :: Maybe WidgetStyleSetCallback

onWidgetStyleSet :: (GObject a, MonadIO m) => a -> WidgetStyleSetCallback -> m SignalHandlerId

wrap_WidgetStyleSetCallback :: WidgetStyleSetCallback -> Ptr () -> Ptr Style -> Ptr () -> IO ()

styleUpdated

type C_WidgetStyleUpdatedCallback = Ptr () -> Ptr () -> IO ()

type WidgetStyleUpdatedCallback = IO ()

data WidgetStyleUpdatedSignalInfo

Instances

SignalInfo WidgetStyleUpdatedSignalInfo

Associated Types

type HaskellCallbackType WidgetStyleUpdatedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetStyleUpdatedSignalInfo -> o -> HaskellCallbackType WidgetStyleUpdatedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetStyleUpdatedSignalInfo

type HaskellCallbackType WidgetStyleUpdatedSignalInfo = WidgetStyleUpdatedCallback

afterWidgetStyleUpdated :: (GObject a, MonadIO m) => a -> WidgetStyleUpdatedCallback -> m SignalHandlerId

genClosure_WidgetStyleUpdated :: WidgetStyleUpdatedCallback -> IO Closure

mk_WidgetStyleUpdatedCallback :: C_WidgetStyleUpdatedCallback -> IO (FunPtr C_WidgetStyleUpdatedCallback)

noWidgetStyleUpdatedCallback :: Maybe WidgetStyleUpdatedCallback

onWidgetStyleUpdated :: (GObject a, MonadIO m) => a -> WidgetStyleUpdatedCallback -> m SignalHandlerId

wrap_WidgetStyleUpdatedCallback :: WidgetStyleUpdatedCallback -> Ptr () -> Ptr () -> IO ()

touchEvent

type C_WidgetTouchEventCallback = Ptr () -> Ptr Event -> Ptr () -> IO CInt

type WidgetTouchEventCallback = Event -> IO Bool

data WidgetTouchEventSignalInfo

Instances

SignalInfo WidgetTouchEventSignalInfo

Associated Types

type HaskellCallbackType WidgetTouchEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetTouchEventSignalInfo -> o -> HaskellCallbackType WidgetTouchEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetTouchEventSignalInfo

type HaskellCallbackType WidgetTouchEventSignalInfo = WidgetTouchEventCallback

afterWidgetTouchEvent :: (GObject a, MonadIO m) => a -> WidgetTouchEventCallback -> m SignalHandlerId

genClosure_WidgetTouchEvent :: WidgetTouchEventCallback -> IO Closure

mk_WidgetTouchEventCallback :: C_WidgetTouchEventCallback -> IO (FunPtr C_WidgetTouchEventCallback)

noWidgetTouchEventCallback :: Maybe WidgetTouchEventCallback

onWidgetTouchEvent :: (GObject a, MonadIO m) => a -> WidgetTouchEventCallback -> m SignalHandlerId

wrap_WidgetTouchEventCallback :: WidgetTouchEventCallback -> Ptr () -> Ptr Event -> Ptr () -> IO CInt

unmap

type C_WidgetUnmapCallback = Ptr () -> Ptr () -> IO ()

type WidgetUnmapCallback = IO ()

data WidgetUnmapSignalInfo

Instances

SignalInfo WidgetUnmapSignalInfo

Associated Types

type HaskellCallbackType WidgetUnmapSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetUnmapSignalInfo -> o -> HaskellCallbackType WidgetUnmapSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetUnmapSignalInfo

type HaskellCallbackType WidgetUnmapSignalInfo = WidgetUnmapCallback

afterWidgetUnmap :: (GObject a, MonadIO m) => a -> WidgetUnmapCallback -> m SignalHandlerId

genClosure_WidgetUnmap :: WidgetUnmapCallback -> IO Closure

mk_WidgetUnmapCallback :: C_WidgetUnmapCallback -> IO (FunPtr C_WidgetUnmapCallback)

noWidgetUnmapCallback :: Maybe WidgetUnmapCallback

onWidgetUnmap :: (GObject a, MonadIO m) => a -> WidgetUnmapCallback -> m SignalHandlerId

wrap_WidgetUnmapCallback :: WidgetUnmapCallback -> Ptr () -> Ptr () -> IO ()

unmapEvent

type C_WidgetUnmapEventCallback = Ptr () -> Ptr EventAny -> Ptr () -> IO CInt

type WidgetUnmapEventCallback = EventAny -> IO Bool

data WidgetUnmapEventSignalInfo

Instances

SignalInfo WidgetUnmapEventSignalInfo

Associated Types

type HaskellCallbackType WidgetUnmapEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetUnmapEventSignalInfo -> o -> HaskellCallbackType WidgetUnmapEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetUnmapEventSignalInfo

type HaskellCallbackType WidgetUnmapEventSignalInfo = WidgetUnmapEventCallback

afterWidgetUnmapEvent :: (GObject a, MonadIO m) => a -> WidgetUnmapEventCallback -> m SignalHandlerId

genClosure_WidgetUnmapEvent :: WidgetUnmapEventCallback -> IO Closure

mk_WidgetUnmapEventCallback :: C_WidgetUnmapEventCallback -> IO (FunPtr C_WidgetUnmapEventCallback)

noWidgetUnmapEventCallback :: Maybe WidgetUnmapEventCallback

onWidgetUnmapEvent :: (GObject a, MonadIO m) => a -> WidgetUnmapEventCallback -> m SignalHandlerId

wrap_WidgetUnmapEventCallback :: WidgetUnmapEventCallback -> Ptr () -> Ptr EventAny -> Ptr () -> IO CInt

unrealize

type C_WidgetUnrealizeCallback = Ptr () -> Ptr () -> IO ()

type WidgetUnrealizeCallback = IO ()

data WidgetUnrealizeSignalInfo

Instances

SignalInfo WidgetUnrealizeSignalInfo

Associated Types

type HaskellCallbackType WidgetUnrealizeSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetUnrealizeSignalInfo -> o -> HaskellCallbackType WidgetUnrealizeSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetUnrealizeSignalInfo

type HaskellCallbackType WidgetUnrealizeSignalInfo = WidgetUnrealizeCallback

afterWidgetUnrealize :: (GObject a, MonadIO m) => a -> WidgetUnrealizeCallback -> m SignalHandlerId

genClosure_WidgetUnrealize :: WidgetUnrealizeCallback -> IO Closure

mk_WidgetUnrealizeCallback :: C_WidgetUnrealizeCallback -> IO (FunPtr C_WidgetUnrealizeCallback)

noWidgetUnrealizeCallback :: Maybe WidgetUnrealizeCallback

onWidgetUnrealize :: (GObject a, MonadIO m) => a -> WidgetUnrealizeCallback -> m SignalHandlerId

wrap_WidgetUnrealizeCallback :: WidgetUnrealizeCallback -> Ptr () -> Ptr () -> IO ()

visibilityNotifyEvent

type C_WidgetVisibilityNotifyEventCallback = Ptr () -> Ptr EventVisibility -> Ptr () -> IO CInt

type WidgetVisibilityNotifyEventCallback = EventVisibility -> IO Bool

Deprecated: (Since version 3.12)Modern composited windowing systems with pervasive transparency make it impossible to track the visibility of a window reliably, so this signal can not be guaranteed to provide useful information.

data WidgetVisibilityNotifyEventSignalInfo

Instances

SignalInfo WidgetVisibilityNotifyEventSignalInfo

Associated Types

type HaskellCallbackType WidgetVisibilityNotifyEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetVisibilityNotifyEventSignalInfo -> o -> HaskellCallbackType WidgetVisibilityNotifyEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetVisibilityNotifyEventSignalInfo

type HaskellCallbackType WidgetVisibilityNotifyEventSignalInfo = WidgetVisibilityNotifyEventCallback

afterWidgetVisibilityNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetVisibilityNotifyEventCallback -> m SignalHandlerId

genClosure_WidgetVisibilityNotifyEvent :: WidgetVisibilityNotifyEventCallback -> IO Closure

mk_WidgetVisibilityNotifyEventCallback :: C_WidgetVisibilityNotifyEventCallback -> IO (FunPtr C_WidgetVisibilityNotifyEventCallback)

noWidgetVisibilityNotifyEventCallback :: Maybe WidgetVisibilityNotifyEventCallback

onWidgetVisibilityNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetVisibilityNotifyEventCallback -> m SignalHandlerId

wrap_WidgetVisibilityNotifyEventCallback :: WidgetVisibilityNotifyEventCallback -> Ptr () -> Ptr EventVisibility -> Ptr () -> IO CInt

windowStateEvent

type C_WidgetWindowStateEventCallback = Ptr () -> Ptr EventWindowState -> Ptr () -> IO CInt

type WidgetWindowStateEventCallback = EventWindowState -> IO Bool

data WidgetWindowStateEventSignalInfo

Instances

SignalInfo WidgetWindowStateEventSignalInfo

Associated Types

type HaskellCallbackType WidgetWindowStateEventSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o WidgetWindowStateEventSignalInfo -> o -> HaskellCallbackType WidgetWindowStateEventSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType WidgetWindowStateEventSignalInfo

type HaskellCallbackType WidgetWindowStateEventSignalInfo = WidgetWindowStateEventCallback

afterWidgetWindowStateEvent :: (GObject a, MonadIO m) => a -> WidgetWindowStateEventCallback -> m SignalHandlerId

genClosure_WidgetWindowStateEvent :: WidgetWindowStateEventCallback -> IO Closure

mk_WidgetWindowStateEventCallback :: C_WidgetWindowStateEventCallback -> IO (FunPtr C_WidgetWindowStateEventCallback)

noWidgetWindowStateEventCallback :: Maybe WidgetWindowStateEventCallback

onWidgetWindowStateEvent :: (GObject a, MonadIO m) => a -> WidgetWindowStateEventCallback -> m SignalHandlerId

wrap_WidgetWindowStateEventCallback :: WidgetWindowStateEventCallback -> Ptr () -> Ptr EventWindowState -> Ptr () -> IO CInt