OverlayProtocol
public protocol OverlayProtocol : BinProtocol
GtkOverlay is a container which contains a single main child, on top
of which it can place “overlay” widgets. The position of each overlay
widget is determined by its GtkWidget:halign
and GtkWidget:valign
properties. E.g. a widget with both alignments set to GTK_ALIGN_START
will be placed at the top left corner of the GtkOverlay container,
whereas an overlay with halign set to GTK_ALIGN_CENTER
and valign set
to GTK_ALIGN_END
will be placed a the bottom edge of the GtkOverlay,
horizontally centered. The position can be adjusted by setting the margin
properties of the child to non-zero values.
More complicated placement of overlays is possible by connecting
to the GtkOverlay::get-child-position
signal.
An overlay’s minimum and natural sizes are those of its main child. The sizes of overlay children are not considered when measuring these preferred sizes.
GtkOverlay as GtkBuildable
The GtkOverlay implementation of the GtkBuildable interface
supports placing a child as an overlay by specifying “overlay” as
the “type” attribute of a <child>
element.
CSS nodes
GtkOverlay has a single CSS node with the name “overlay”. Overlay children whose alignments cause them to be positioned at an edge get the style classes “.left”, “.right”, “.top”, and/or “.bottom” according to their position.
The OverlayProtocol
protocol exposes the methods and properties of an underlying GtkOverlay
instance.
The default implementation of these can be found in the protocol extension below.
For a concrete class that implements these methods and properties, see Overlay
.
Alternatively, use OverlayRef
as a lighweight, unowned
reference if you already have an instance you just want to use.
-
Untyped pointer to the underlying
GtkOverlay
instance.Declaration
Swift
var ptr: UnsafeMutableRawPointer! { get }
-
overlay_ptr
Default implementationTyped pointer to the underlying
GtkOverlay
instance.Default Implementation
Return the stored, untyped pointer as a typed pointer to the
GtkOverlay
instance.Declaration
Swift
var overlay_ptr: UnsafeMutablePointer<GtkOverlay>! { get }
-
Required Initialiser for types conforming to
OverlayProtocol
Declaration
Swift
init(raw: UnsafeMutableRawPointer)
-
bind(property:
Extension methodto: _: flags: transformFrom: transformTo: ) Bind a
OverlayPropertyName
source property to a given target object.Declaration
Swift
@discardableResult @inlinable func bind<Q, T>(property source_property: OverlayPropertyName, to target: T, _ target_property: Q, flags f: BindingFlags = .default, transformFrom transform_from: @escaping GLibObject.ValueTransformer = { $0.transform(destValue: $1) }, transformTo transform_to: @escaping GLibObject.ValueTransformer = { $0.transform(destValue: $1) }) -> BindingRef! where Q : PropertyNameProtocol, T : ObjectProtocol
Parameters
source_property
the source property to bind
target
the target object to bind to
target_property
the target property to bind to
flags
the flags to pass to the
Binding
transform_from
ValueTransformer
to use for forward transformationtransform_to
ValueTransformer
to use for backwards transformationReturn Value
binding reference or
nil
in case of an error -
get(property:
Extension method) Get the value of a Overlay property
Declaration
Swift
@inlinable func get(property: OverlayPropertyName) -> GLibObject.Value
Parameters
property
the property to get the value for
Return Value
the value of the named property
-
set(property:
Extension methodvalue: ) Set the value of a Overlay property. Note that this will only have an effect on properties that are writable and not construct-only!
Declaration
Swift
@inlinable func set(property: OverlayPropertyName, value v: GLibObject.Value)
Parameters
property
the property to get the value for
Return Value
the value of the named property
-
connect(signal:
Extension methodflags: handler: ) Connect a Swift signal handler to the given, typed
OverlaySignalName
signalDeclaration
Swift
@discardableResult @inlinable func connect(signal s: OverlaySignalName, flags f: ConnectFlags = ConnectFlags(0), handler h: @escaping SignalHandler) -> Int
Parameters
signal
The signal to connect
flags
The connection flags to use
data
A pointer to user data to provide to the callback
destroyData
A
GClosureNotify
C function to destroy the data pointed to byuserData
handler
The Swift signal handler (function or callback) to invoke on the given signal
Return Value
The signal handler ID (always greater than 0 for successful connections)
-
connect(signal:
Extension methodflags: data: destroyData: signalHandler: ) Connect a C signal handler to the given, typed
OverlaySignalName
signalDeclaration
Swift
@discardableResult @inlinable func connect(signal s: OverlaySignalName, flags f: ConnectFlags = ConnectFlags(0), data userData: gpointer!, destroyData destructor: GClosureNotify? = nil, signalHandler h: @escaping GCallback) -> Int
Parameters
signal
The signal to connect
flags
The connection flags to use
data
A pointer to user data to provide to the callback
destroyData
A
GClosureNotify
C function to destroy the data pointed to byuserData
signalHandler
The C function to be called on the given signal
Return Value
The signal handler ID (always greater than 0 for successful connections)
-
getChildPositionSignal
Extension methodThe
get-child-position
signal is emitted to determine the position and size of any overlay child widgets. A handler for this signal should fillallocation
with the desired position and size forwidget
, relative to the ‘main’ child ofoverlay
.The default handler for this signal uses the
widget
‘s halign and valign properties to determine the position and gives the widget its natural size (except that an alignment ofGTK_ALIGN_FILL
will cause the overlay to be full-width/height). If the main child is aGtkScrolledWindow
, the overlays are placed relative to its contents.Note
This represents the underlyingget-child-position
signalWarning
aonGetChildPosition
wrapper for this signal could not be generated because it contains unimplemented features: { (2)out
orinout
argument direction is not allowed }Note
Instead, you can connectgetChildPositionSignal
using theconnect(signal:)
methodsDeclaration
Swift
static var getChildPositionSignal: OverlaySignalName { get }
Parameters
flags
Flags
unownedSelf
Reference to instance of self
widget
the child widget to position
allocation
return location for the allocation
handler
true
if theallocation
has been filled
-
addOverlay(widget:
Extension method) Adds
widget
tooverlay
.The widget will be stacked on top of the main widget added with
gtk_container_add()
.The position at which
widget
is placed is determined from itsGtkWidget:halign
andGtkWidget:valign
properties.Declaration
Swift
@inlinable func addOverlay<WidgetT>(widget: WidgetT) where WidgetT : WidgetProtocol
-
getOverlayPassThrough(widget:
Extension method) Convenience function to get the value of the
GtkOverlay:pass-through
child property forwidget
.Declaration
Swift
@inlinable func getOverlayPassThrough<WidgetT>(widget: WidgetT) -> Bool where WidgetT : WidgetProtocol
-
reorderOverlay(child:
Extension methodindex: ) Moves
child
to a newindex
in the list ofoverlay
children. The list contains overlays in the order that these were added tooverlay
by default. See alsoGtkOverlay:index
.A widget’s index in the
overlay
children list determines which order the children are drawn if they overlap. The first child is drawn at the bottom. It also affects the default focus chain order.Declaration
Swift
@inlinable func reorderOverlay<WidgetT>(child: WidgetT, index: Int) where WidgetT : WidgetProtocol
-
setOverlayPassThrough(widget:
Extension methodpassThrough: ) Convenience function to set the value of the
GtkOverlay:pass-through
child property forwidget
.Declaration
Swift
@inlinable func setOverlayPassThrough<WidgetT>(widget: WidgetT, passThrough: Bool) where WidgetT : WidgetProtocol
-
parent
Extension methodUndocumented
Declaration
Swift
@inlinable var parent: GtkBin { get }